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  */
HWTEST_F(NativeNodeTest, NativeNodeTest001, TestSize.Level1)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  */
HWTEST_F(NativeNodeTest, NativeNodeTest002, TestSize.Level1)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  */
HWTEST_F(NativeNodeTest, NativeNodeTest003, TestSize.Level1)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  */
HWTEST_F(NativeNodeTest, NativeNodeTest004, TestSize.Level1)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  */
HWTEST_F(NativeNodeTest, NativeNodeTest005, TestSize.Level1)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  */
HWTEST_F(NativeNodeTest, NativeNodeTest006, TestSize.Level1)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  */
HWTEST_F(NativeNodeTest, NativeNodeTest007, TestSize.Level1)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  */
HWTEST_F(NativeNodeTest, NativeNodeTest008, TestSize.Level1)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  */
HWTEST_F(NativeNodeTest, NativeNodeTest009, TestSize.Level1)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  */
HWTEST_F(NativeNodeTest, NativeNodeTest010, TestSize.Level1)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  */
HWTEST_F(NativeNodeTest, NativeNodeTest011, TestSize.Level1)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  */
HWTEST_F(NativeNodeTest, NativeNodeTest012, TestSize.Level1)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  */
HWTEST_F(NativeNodeTest, NativeNodeTest013, TestSize.Level1)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  */
HWTEST_F(NativeNodeTest, NativeNodeTest014, TestSize.Level1)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  */
HWTEST_F(NativeNodeTest, NativeNodeTest015, TestSize.Level1)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  */
HWTEST_F(NativeNodeTest, NativeNodeTest016, TestSize.Level1)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  */
HWTEST_F(NativeNodeTest, NativeNodeTest017, TestSize.Level1)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  */
HWTEST_F(NativeNodeTest, NativeNodeTest018, TestSize.Level1)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  */
HWTEST_F(NativeNodeTest, NativeNodeTest019, TestSize.Level1)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 
2253     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_XCOMPONENT_TYPE), ARKUI_ERROR_CODE_NO_ERROR);
2254 
2255     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_XCOMPONENT_ID), nullptr);
2256     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_XCOMPONENT_TYPE), nullptr);
2257     nodeAPI->disposeNode(rootNode);
2258 }
2259 
2260 /**
2261  * @tc.name: NativeNodeTest020
2262  * @tc.desc: Test datePickerNode function.
2263  * @tc.type: FUNC
2264  */
HWTEST_F(NativeNodeTest, NativeNodeTest020, TestSize.Level1)2265 HWTEST_F(NativeNodeTest, NativeNodeTest020, TestSize.Level1)
2266 {
2267     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
2268         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
2269 
2270     auto rootNode = new ArkUI_Node({ARKUI_NODE_DATE_PICKER, nullptr});
2271     ArkUI_NumberValue value[] = {{.i32 = true}};
2272     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
2273     nodeAPI->setAttribute(rootNode, NODE_DATE_PICKER_LUNAR, &item);
2274     item.string = "1970-1-1";
2275     nodeAPI->setAttribute(rootNode, NODE_DATE_PICKER_START, &item);
2276     nodeAPI->setAttribute(rootNode, NODE_DATE_PICKER_END, &item);
2277     nodeAPI->setAttribute(rootNode, NODE_DATE_PICKER_SELECTED, &item);
2278     item.string = "#ff182431;14;normal;Arial;normal";
2279     nodeAPI->setAttribute(rootNode, NODE_DATE_PICKER_DISAPPEAR_TEXT_STYLE, &item);
2280     nodeAPI->setAttribute(rootNode, NODE_DATE_PICKER_TEXT_STYLE, &item);
2281     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_DATE_PICKER_SELECTED_TEXT_STYLE, &item),
2282         ARKUI_ERROR_CODE_NO_ERROR);
2283     item.string = "#ff182431;14;normal;Arial;test";
2284     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_DATE_PICKER_SELECTED_TEXT_STYLE, &item),
2285         ARKUI_ERROR_CODE_NO_ERROR);
2286     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_DATE_PICKER_LUNAR), ARKUI_ERROR_CODE_NO_ERROR);
2287     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_DATE_PICKER_START), ARKUI_ERROR_CODE_NO_ERROR);
2288     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_DATE_PICKER_END), ARKUI_ERROR_CODE_NO_ERROR);
2289     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_DATE_PICKER_SELECTED), ARKUI_ERROR_CODE_NO_ERROR);
2290     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_DATE_PICKER_DISAPPEAR_TEXT_STYLE), ARKUI_ERROR_CODE_NO_ERROR);
2291     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_DATE_PICKER_TEXT_STYLE), ARKUI_ERROR_CODE_NO_ERROR);
2292     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_DATE_PICKER_SELECTED_TEXT_STYLE), ARKUI_ERROR_CODE_NO_ERROR);
2293 
2294     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_DATE_PICKER_LUNAR), nullptr);
2295     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_DATE_PICKER_START), nullptr);
2296     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_DATE_PICKER_END), nullptr);
2297     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_DATE_PICKER_SELECTED), nullptr);
2298     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_DATE_PICKER_DISAPPEAR_TEXT_STYLE), nullptr);
2299     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_DATE_PICKER_TEXT_STYLE), nullptr);
2300     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_DATE_PICKER_SELECTED_TEXT_STYLE), nullptr);
2301     nodeAPI->disposeNode(rootNode);
2302 }
2303 
2304 /**
2305  * @tc.name: NativeNodeTest021
2306  * @tc.desc: Test timePickerNode function.
2307  * @tc.type: FUNC
2308  */
HWTEST_F(NativeNodeTest, NativeNodeTest021, TestSize.Level1)2309 HWTEST_F(NativeNodeTest, NativeNodeTest021, TestSize.Level1)
2310 {
2311     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
2312         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
2313     auto rootNode = new ArkUI_Node({ARKUI_NODE_TIME_PICKER, nullptr});
2314     ArkUI_NumberValue value[] = {{.i32 = true}};
2315     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
2316     item.string = "11-59";
2317     nodeAPI->setAttribute(rootNode, NODE_TIME_PICKER_SELECTED, &item);
2318     nodeAPI->setAttribute(rootNode, NODE_TIME_PICKER_USE_MILITARY_TIME, &item);
2319     item.string = "#ff182431;14;normal;Arial;normal";
2320     nodeAPI->setAttribute(rootNode, NODE_TIME_PICKER_DISAPPEAR_TEXT_STYLE, &item);
2321     nodeAPI->setAttribute(rootNode, NODE_TIME_PICKER_TEXT_STYLE, &item);
2322     nodeAPI->setAttribute(rootNode, NODE_TIME_PICKER_SELECTED_TEXT_STYLE, &item);
2323     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TIME_PICKER_SELECTED), ARKUI_ERROR_CODE_NO_ERROR);
2324     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TIME_PICKER_USE_MILITARY_TIME), ARKUI_ERROR_CODE_NO_ERROR);
2325     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TIME_PICKER_DISAPPEAR_TEXT_STYLE), ARKUI_ERROR_CODE_NO_ERROR);
2326     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TIME_PICKER_TEXT_STYLE), ARKUI_ERROR_CODE_NO_ERROR);
2327     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TIME_PICKER_SELECTED_TEXT_STYLE), ARKUI_ERROR_CODE_NO_ERROR);
2328 
2329     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TIME_PICKER_SELECTED), nullptr);
2330     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TIME_PICKER_USE_MILITARY_TIME), nullptr);
2331     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TIME_PICKER_DISAPPEAR_TEXT_STYLE), nullptr);
2332     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TIME_PICKER_TEXT_STYLE), nullptr);
2333     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TIME_PICKER_SELECTED_TEXT_STYLE), nullptr);
2334     nodeAPI->disposeNode(rootNode);
2335 }
2336 
2337 /**
2338  * @tc.name: NativeNodeTest022
2339  * @tc.desc: Test textPickerNode function.
2340  * @tc.type: FUNC
2341  */
HWTEST_F(NativeNodeTest, NativeNodeTest022, TestSize.Level1)2342 HWTEST_F(NativeNodeTest, NativeNodeTest022, TestSize.Level1)
2343 {
2344     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
2345         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
2346     auto rootNode = new ArkUI_Node({ARKUI_NODE_TEXT_PICKER, nullptr});
2347     ArkUI_NumberValue value[] = {{.i32 = ARKUI_TEXTPICKER_RANGETYPE_SINGLE}};
2348     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
2349     item.string = "1;2;3";
2350     nodeAPI->setAttribute(rootNode, NODE_TEXT_PICKER_OPTION_RANGE, &item);
2351     nodeAPI->setAttribute(rootNode, NODE_TEXT_PICKER_OPTION_VALUE, &item);
2352     item.string = "#ff182431;14;normal;Arial;normal";
2353     nodeAPI->setAttribute(rootNode, NODE_TEXT_PICKER_DISAPPEAR_TEXT_STYLE, &item);
2354     nodeAPI->setAttribute(rootNode, NODE_TEXT_PICKER_TEXT_STYLE, &item);
2355     nodeAPI->setAttribute(rootNode, NODE_TEXT_PICKER_SELECTED_TEXT_STYLE, &item);
2356 
2357     value[0].u32 = 0;
2358     nodeAPI->setAttribute(rootNode, NODE_TEXT_PICKER_OPTION_SELECTED, &item);
2359     value[0].i32 = 0;
2360     nodeAPI->setAttribute(rootNode, NODE_TEXT_PICKER_CAN_LOOP, &item);
2361     nodeAPI->setAttribute(rootNode, NODE_TEXT_PICKER_SELECTED_INDEX, &item);
2362 
2363     value[0].f32 = 10.0f;
2364     nodeAPI->setAttribute(rootNode, NODE_TEXT_PICKER_DEFAULT_PICKER_ITEM_HEIGHT, &item);
2365     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_PICKER_OPTION_RANGE), ARKUI_ERROR_CODE_NO_ERROR);
2366     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_PICKER_OPTION_SELECTED), ARKUI_ERROR_CODE_NO_ERROR);
2367     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_PICKER_OPTION_VALUE), ARKUI_ERROR_CODE_NO_ERROR);
2368     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_PICKER_DISAPPEAR_TEXT_STYLE), ARKUI_ERROR_CODE_NO_ERROR);
2369     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_PICKER_TEXT_STYLE), ARKUI_ERROR_CODE_NO_ERROR);
2370     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_PICKER_SELECTED_TEXT_STYLE), ARKUI_ERROR_CODE_NO_ERROR);
2371     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_PICKER_SELECTED_INDEX), ARKUI_ERROR_CODE_NO_ERROR);
2372     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_TEXT_PICKER_CAN_LOOP), ARKUI_ERROR_CODE_NO_ERROR);
2373     EXPECT_EQ(nodeAPI->resetAttribute(
2374         rootNode, NODE_TEXT_PICKER_DEFAULT_PICKER_ITEM_HEIGHT), ARKUI_ERROR_CODE_NO_ERROR);
2375 
2376     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_PICKER_OPTION_RANGE), nullptr);
2377     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_PICKER_OPTION_SELECTED), nullptr);
2378     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_PICKER_OPTION_VALUE), nullptr);
2379     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_PICKER_DISAPPEAR_TEXT_STYLE), nullptr);
2380     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_PICKER_TEXT_STYLE), nullptr);
2381     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_PICKER_SELECTED_TEXT_STYLE), nullptr);
2382     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_PICKER_SELECTED_INDEX), nullptr);
2383     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_PICKER_CAN_LOOP), nullptr);
2384     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_TEXT_PICKER_DEFAULT_PICKER_ITEM_HEIGHT), nullptr);
2385     nodeAPI->disposeNode(rootNode);
2386 }
2387 
2388 /**
2389  * @tc.name: NativeNodeTest023
2390  * @tc.desc: Test calendarPickerNode function.
2391  * @tc.type: FUNC
2392  */
HWTEST_F(NativeNodeTest, NativeNodeTest023, TestSize.Level1)2393 HWTEST_F(NativeNodeTest, NativeNodeTest023, TestSize.Level1)
2394 {
2395     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
2396         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
2397     auto rootNode = new ArkUI_Node({ARKUI_NODE_CALENDAR_PICKER, nullptr});
2398     float offset = 10.0f;
2399     ArkUI_NumberValue value[] = {{.f32 = offset}};
2400     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
2401     ArkUI_NumberValue value3[] = {{.u32 = 2024}, {.u32 = 1}, {.u32 = 1}};
2402     ArkUI_AttributeItem item3 = {value3, sizeof(value3) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
2403     nodeAPI->setAttribute(rootNode, NODE_CALENDAR_PICKER_HINT_RADIUS, &item);
2404     nodeAPI->setAttribute(rootNode, NODE_CALENDAR_PICKER_SELECTED_DATE, &item3);
2405 
2406     value[0].i32 = ARKUI_CALENDAR_ALIGNMENT_START;
2407     nodeAPI->setAttribute(rootNode, NODE_CALENDAR_PICKER_EDGE_ALIGNMENT, &item);
2408     value3[0].i32 = ARKUI_CALENDAR_ALIGNMENT_START;
2409     value3[1].f32 = offset;
2410     value3[2].f32 = offset;
2411     nodeAPI->setAttribute(rootNode, NODE_CALENDAR_PICKER_EDGE_ALIGNMENT, &item3);
2412     value3[0].u32 = 0xFFFF0000;
2413     value3[1].f32 = offset;
2414     value3[2].i32 = ARKUI_FONT_WEIGHT_NORMAL;
2415     nodeAPI->setAttribute(rootNode, NODE_CALENDAR_PICKER_TEXT_STYLE, &item3);
2416     item3.size = -1;
2417     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CALENDAR_PICKER_TEXT_STYLE, &item3), ARKUI_ERROR_CODE_PARAM_INVALID);
2418 
2419     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_CALENDAR_PICKER_HINT_RADIUS), ARKUI_ERROR_CODE_NO_ERROR);
2420     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_CALENDAR_PICKER_SELECTED_DATE), ARKUI_ERROR_CODE_NO_ERROR);
2421     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_CALENDAR_PICKER_EDGE_ALIGNMENT), ARKUI_ERROR_CODE_NO_ERROR);
2422     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_CALENDAR_PICKER_TEXT_STYLE), ARKUI_ERROR_CODE_NO_ERROR);
2423 
2424     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_CALENDAR_PICKER_HINT_RADIUS), nullptr);
2425     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_CALENDAR_PICKER_SELECTED_DATE), nullptr);
2426     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_CALENDAR_PICKER_EDGE_ALIGNMENT), nullptr);
2427     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_CALENDAR_PICKER_TEXT_STYLE), nullptr);
2428     nodeAPI->disposeNode(rootNode);
2429 }
2430 
2431 /**
2432  * @tc.name: NativeNodeTest024
2433  * @tc.desc: Test sliderNode function.
2434  * @tc.type: FUNC
2435  */
HWTEST_F(NativeNodeTest, NativeNodeTest024, TestSize.Level1)2436 HWTEST_F(NativeNodeTest, NativeNodeTest024, TestSize.Level1)
2437 {
2438     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
2439         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
2440     auto rootNode = nodeAPI->createNode(ARKUI_NODE_SLIDER);
2441     ASSERT_NE(rootNode, nullptr);
2442     uint32_t color = 0xFFFF0000;
2443     float size = 10.0f;
2444     ArkUI_NumberValue value[] = {{.u32 = color}};
2445     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
2446     ArkUI_NumberValue blockStyle[] = {{.i32 = ARKUI_SLIDER_BLOCK_STYLE_IMAGE }, {.i32 = ARKUI_CLIP_TYPE_PATH},
2447         {.f32 = size}, {.f32 = size}, {.f32 = size}};
2448     ArkUI_AttributeItem blockStyleItem = {blockStyle, sizeof(blockStyle) / sizeof(ArkUI_NumberValue), "test", nullptr};
2449     nodeAPI->setAttribute(rootNode, NODE_SLIDER_BLOCK_COLOR, &item);
2450     nodeAPI->setAttribute(rootNode, NODE_SLIDER_TRACK_COLOR, &item);
2451     nodeAPI->setAttribute(rootNode, NODE_SLIDER_SELECTED_COLOR, &item);
2452     value[0].i32 = true;
2453     nodeAPI->setAttribute(rootNode, NODE_SLIDER_SHOW_STEPS, &item);
2454     nodeAPI->setAttribute(rootNode, NODE_SLIDER_REVERSE, &item);
2455     value[0].i32 = ARKUI_SLIDER_DIRECTION_VERTICAL;
2456     nodeAPI->setAttribute(rootNode, NODE_SLIDER_DIRECTION, &item);
2457     value[0].i32 = ARKUI_SLIDER_STYLE_OUT_SET;
2458     nodeAPI->setAttribute(rootNode, NODE_SLIDER_STYLE, &item);
2459     value[0].f32 = size;
2460     nodeAPI->setAttribute(rootNode, NODE_SLIDER_VALUE, &item);
2461     nodeAPI->setAttribute(rootNode, NODE_SLIDER_MIN_VALUE, &item);
2462     nodeAPI->setAttribute(rootNode, NODE_SLIDER_MAX_VALUE, &item);
2463     nodeAPI->setAttribute(rootNode, NODE_SLIDER_STEP, &item);
2464     nodeAPI->setAttribute(rootNode, NODE_SLIDER_TRACK_THICKNESS, &item);
2465 
2466     nodeAPI->setAttribute(rootNode, NODE_SLIDER_BLOCK_STYLE, &blockStyleItem);
2467     blockStyle[0].i32 = ARKUI_SLIDER_BLOCK_STYLE_SHAPE;
2468     nodeAPI->setAttribute(rootNode, NODE_SLIDER_BLOCK_STYLE, &blockStyleItem);
2469     blockStyle[1].i32 = ARKUI_CLIP_TYPE_RECTANGLE;
2470     nodeAPI->setAttribute(rootNode, NODE_SLIDER_BLOCK_STYLE, &blockStyleItem);
2471     blockStyle[0].i32 = ARKUI_SLIDER_BLOCK_STYLE_DEFAULT;
2472     nodeAPI->setAttribute(rootNode, NODE_SLIDER_BLOCK_STYLE, &blockStyleItem);
2473     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SLIDER_BLOCK_COLOR), ARKUI_ERROR_CODE_NO_ERROR);
2474     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SLIDER_TRACK_COLOR), ARKUI_ERROR_CODE_NO_ERROR);
2475     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SLIDER_SELECTED_COLOR), ARKUI_ERROR_CODE_NO_ERROR);
2476     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SLIDER_SHOW_STEPS), ARKUI_ERROR_CODE_NO_ERROR);
2477     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SLIDER_BLOCK_STYLE), ARKUI_ERROR_CODE_NO_ERROR);
2478     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SLIDER_VALUE), ARKUI_ERROR_CODE_NO_ERROR);
2479     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SLIDER_MIN_VALUE), ARKUI_ERROR_CODE_NO_ERROR);
2480     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SLIDER_MAX_VALUE), ARKUI_ERROR_CODE_NO_ERROR);
2481     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SLIDER_STEP), ARKUI_ERROR_CODE_NO_ERROR);
2482     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SLIDER_DIRECTION), ARKUI_ERROR_CODE_NO_ERROR);
2483     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SLIDER_REVERSE), ARKUI_ERROR_CODE_NO_ERROR);
2484     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SLIDER_STYLE), ARKUI_ERROR_CODE_NO_ERROR);
2485     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SLIDER_TRACK_THICKNESS), ARKUI_ERROR_CODE_NO_ERROR);
2486 
2487     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SLIDER_BLOCK_COLOR), nullptr);
2488     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SLIDER_TRACK_COLOR), nullptr);
2489     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SLIDER_SELECTED_COLOR), nullptr);
2490     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SLIDER_SHOW_STEPS), nullptr);
2491     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SLIDER_BLOCK_STYLE), nullptr);
2492     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SLIDER_VALUE), nullptr);
2493     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SLIDER_MIN_VALUE), nullptr);
2494     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SLIDER_MAX_VALUE), nullptr);
2495     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SLIDER_STEP), nullptr);
2496     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SLIDER_DIRECTION), nullptr);
2497     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SLIDER_REVERSE), nullptr);
2498     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SLIDER_STYLE), nullptr);
2499     EXPECT_EQ(nodeAPI->getAttribute(rootNode, NODE_SLIDER_TRACK_THICKNESS), nullptr);
2500     nodeAPI->disposeNode(rootNode);
2501 }
2502 
2503 /**
2504  * @tc.name: NativeNodeTest025
2505  * @tc.desc: Test radioNode function.
2506  * @tc.type: FUNC
2507  */
HWTEST_F(NativeNodeTest, NativeNodeTest025, TestSize.Level1)2508 HWTEST_F(NativeNodeTest, NativeNodeTest025, TestSize.Level1)
2509 {
2510     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
2511         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
2512     auto rootNode = nodeAPI->createNode(ARKUI_NODE_RADIO);
2513     ASSERT_NE(rootNode, nullptr);
2514     uint32_t color = 0xFFFF0000;
2515     ArkUI_NumberValue value[] = {{.i32 = true}};
2516     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
2517     ArkUI_NumberValue style[] = {{.u32 = color}, {.u32 = color}, {.u32 = color}};
2518     ArkUI_AttributeItem styleItem = {style, sizeof(style) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
2519     nodeAPI->setAttribute(rootNode, NODE_RADIO_CHECKED, &item);
2520     item.string = "test";
2521     nodeAPI->setAttribute(rootNode, NODE_RADIO_VALUE, &item);
2522     nodeAPI->setAttribute(rootNode, NODE_RADIO_GROUP, &item);
2523     nodeAPI->setAttribute(rootNode, NODE_RADIO_STYLE, &styleItem);
2524     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_RADIO_CHECKED), ARKUI_ERROR_CODE_NO_ERROR);
2525     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_RADIO_STYLE), ARKUI_ERROR_CODE_NO_ERROR);
2526     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_RADIO_VALUE), ARKUI_ERROR_CODE_NO_ERROR);
2527     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_RADIO_GROUP), ARKUI_ERROR_CODE_NO_ERROR);
2528 
2529     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_RADIO_CHECKED), nullptr);
2530     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_RADIO_STYLE), nullptr);
2531     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_RADIO_VALUE), nullptr);
2532     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_RADIO_GROUP), nullptr);
2533     nodeAPI->disposeNode(rootNode);
2534 }
2535 
2536 /**
2537  * @tc.name: NativeNodeTest026
2538  * @tc.desc: Test scrollNode function.
2539  * @tc.type: FUNC
2540  */
HWTEST_F(NativeNodeTest, NativeNodeTest026, TestSize.Level1)2541 HWTEST_F(NativeNodeTest, NativeNodeTest026, TestSize.Level1)
2542 {
2543     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
2544         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
2545     auto rootNode = nodeAPI->createNode(ARKUI_NODE_SCROLL);
2546     ASSERT_NE(rootNode, nullptr);
2547     float distance = 10.0f;
2548     uint32_t color = 0xFFFF0000;
2549     ArkUI_NumberValue value[] = {{.f32 = distance}};
2550     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue)};
2551     ArkUI_NumberValue value2[] = {{.i32 = true}, {.i32 = true}};
2552     ArkUI_AttributeItem item2 = {value2, sizeof(value2) / sizeof(ArkUI_NumberValue)};
2553     ArkUI_NumberValue scrollsnap[] = {{.i32 = ARKUI_SCROLL_SNAP_ALIGN_NONE}, {.i32 = true}, {.i32 = true},
2554         {.f32 = distance}};
2555     ArkUI_AttributeItem scrollsnapItem = {scrollsnap, sizeof(scrollsnap) / sizeof(ArkUI_NumberValue)};
2556     ArkUI_NumberValue scrollnested[] = {{.i32 = ARKUI_SCROLL_NESTED_MODE_SELF_ONLY},
2557         {.i32 = ARKUI_SCROLL_NESTED_MODE_SELF_ONLY}};
2558     ArkUI_AttributeItem scrollnestedItem = {scrollnested, sizeof(scrollnested) / sizeof(ArkUI_NumberValue)};
2559     ArkUI_NumberValue scrolloffset[] = {{.f32 = distance}, {.f32 = distance}, { .i32 = 1000},
2560         {.i32 = ARKUI_CURVE_LINEAR}, {.i32 = true}};
2561     ArkUI_AttributeItem scrolloffsetItem = {scrolloffset, sizeof(scrolloffset) / sizeof(ArkUI_NumberValue)};
2562     nodeAPI->setAttribute(rootNode, NODE_SCROLL_FRICTION, &item);
2563     nodeAPI->setAttribute(rootNode, NODE_SCROLL_BAR_WIDTH, &item);
2564 
2565     value[0].u32 = color;
2566     nodeAPI->setAttribute(rootNode, NODE_SCROLL_BAR_COLOR, &item);
2567 
2568     value[0].i32 = ARKUI_SCROLL_BAR_DISPLAY_MODE_AUTO;
2569     nodeAPI->setAttribute(rootNode, NODE_SCROLL_BAR_DISPLAY_MODE, &item);
2570     value[0].i32 = ARKUI_SCROLL_DIRECTION_VERTICAL;
2571     nodeAPI->setAttribute(rootNode, NODE_SCROLL_SCROLL_DIRECTION, &item);
2572     value[0].i32 = ARKUI_EDGE_EFFECT_NONE;
2573     nodeAPI->setAttribute(rootNode, NODE_SCROLL_EDGE_EFFECT, &item);
2574     value[0].i32 = true;
2575     nodeAPI->setAttribute(rootNode, NODE_SCROLL_ENABLE_SCROLL_INTERACTION, &item);
2576     nodeAPI->setAttribute(rootNode, NODE_SCROLL_ENABLE_PAGING, &item);
2577     nodeAPI->setAttribute(rootNode, NODE_SCROLL_PAGE, &item);
2578     value[0].i32 = ARKUI_SCROLL_EDGE_TOP;
2579     nodeAPI->setAttribute(rootNode, NODE_SCROLL_EDGE, &item);
2580 
2581     nodeAPI->setAttribute(rootNode, NODE_SCROLL_SNAP, &scrollsnapItem);
2582     nodeAPI->setAttribute(rootNode, NODE_SCROLL_NESTED_SCROLL, &scrollnestedItem);
2583     scrolloffsetItem.size = 2;
2584     nodeAPI->setAttribute(rootNode, NODE_SCROLL_OFFSET, &scrolloffsetItem);
2585     scrolloffsetItem.size = sizeof(scrolloffset) / sizeof(ArkUI_NumberValue);
2586     nodeAPI->setAttribute(rootNode, NODE_SCROLL_OFFSET, &scrolloffsetItem);
2587     scrolloffset[3].i32 = -1;
2588     nodeAPI->setAttribute(rootNode, NODE_SCROLL_OFFSET, &scrolloffsetItem);
2589 
2590     nodeAPI->setAttribute(rootNode, NODE_SCROLL_PAGE, &item2);
2591     value2[1].i32 = -1;
2592     nodeAPI->setAttribute(rootNode, NODE_SCROLL_PAGE, &item2);
2593 
2594     value2[0].f32 = distance;
2595     value2[1].f32 = distance;
2596     nodeAPI->setAttribute(rootNode, NODE_SCROLL_BY, &item2);
2597     nodeAPI->setLengthMetricUnit(rootNode, ARKUI_LENGTH_METRIC_UNIT_PX);
2598     nodeAPI->setAttribute(rootNode, NODE_SCROLL_BY, &item2);
2599     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SCROLL_BAR_DISPLAY_MODE), ARKUI_ERROR_CODE_NO_ERROR);
2600     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SCROLL_BAR_WIDTH), ARKUI_ERROR_CODE_NO_ERROR);
2601     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SCROLL_BAR_COLOR), ARKUI_ERROR_CODE_NO_ERROR);
2602     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SCROLL_SCROLL_DIRECTION), ARKUI_ERROR_CODE_NO_ERROR);
2603     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SCROLL_EDGE_EFFECT), ARKUI_ERROR_CODE_NO_ERROR);
2604     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SCROLL_ENABLE_SCROLL_INTERACTION), ARKUI_ERROR_CODE_NO_ERROR);
2605     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SCROLL_FRICTION), ARKUI_ERROR_CODE_NO_ERROR);
2606     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SCROLL_SNAP), ARKUI_ERROR_CODE_NO_ERROR);
2607     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SCROLL_NESTED_SCROLL), ARKUI_ERROR_CODE_NO_ERROR);
2608     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SCROLL_OFFSET), ARKUI_ERROR_CODE_NO_ERROR);
2609     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SCROLL_EDGE), ARKUI_ERROR_CODE_NO_ERROR);
2610     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SCROLL_ENABLE_PAGING), ARKUI_ERROR_CODE_NO_ERROR);
2611 
2612     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SCROLL_BAR_DISPLAY_MODE), nullptr);
2613     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SCROLL_BAR_WIDTH), nullptr);
2614     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SCROLL_BAR_COLOR), nullptr);
2615     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SCROLL_SCROLL_DIRECTION), nullptr);
2616     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SCROLL_EDGE_EFFECT), nullptr);
2617     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SCROLL_ENABLE_SCROLL_INTERACTION), nullptr);
2618     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SCROLL_FRICTION), nullptr);
2619     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SCROLL_SNAP), nullptr);
2620     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SCROLL_NESTED_SCROLL), nullptr);
2621     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SCROLL_OFFSET), nullptr);
2622     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SCROLL_EDGE), nullptr);
2623     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SCROLL_ENABLE_PAGING), nullptr);
2624     nodeAPI->disposeNode(rootNode);
2625 }
2626 
2627 /**
2628  * @tc.name: NativeNodeTest027
2629  * @tc.desc: Test listNode function.
2630  * @tc.type: FUNC
2631  */
HWTEST_F(NativeNodeTest, NativeNodeTest027, TestSize.Level1)2632 HWTEST_F(NativeNodeTest, NativeNodeTest027, TestSize.Level1)
2633 {
2634     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
2635         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
2636     auto rootNode = new ArkUI_Node({ARKUI_NODE_LIST, nullptr});
2637     auto childNode = new ArkUI_Node({ARKUI_NODE_LIST_ITEM, nullptr});
2638     auto groupNode = new ArkUI_Node({ARKUI_NODE_LIST_ITEM_GROUP, nullptr});
2639 
2640     float distance = 10.0f;
2641     uint32_t color = 0xFFFF0000;
2642     ArkUI_NumberValue value[] = {{.f32 = distance}};
2643     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue)};
2644     ArkUI_NumberValue value2[] = {{.f32 = distance}, {.f32 = distance}};
2645     ArkUI_AttributeItem item2 = {value2, sizeof(value2) / sizeof(ArkUI_NumberValue)};
2646     ArkUI_NumberValue scrollnested[] = {{.i32 = ARKUI_SCROLL_NESTED_MODE_SELF_ONLY},
2647         {.i32 = ARKUI_SCROLL_NESTED_MODE_SELF_ONLY}};
2648     ArkUI_AttributeItem scrollnestedItem = {scrollnested, sizeof(scrollnested) / sizeof(ArkUI_NumberValue)};
2649     ArkUI_NumberValue scrollToIndex[] = {{.i32 = 0}, {.i32 = 1}, {.i32 = ARKUI_SCROLL_ALIGNMENT_START}};
2650     ArkUI_AttributeItem scrollToIndexItem = {scrollToIndex, sizeof(scrollToIndex) / sizeof(ArkUI_NumberValue)};
2651     ArkUI_NumberValue divider[] = {{.u32 = color}, {.f32 = distance}, {.f32 = distance}, {.f32 = distance}};
2652     ArkUI_AttributeItem dividerItem = {divider, sizeof(divider) / sizeof(ArkUI_NumberValue)};
2653     nodeAPI->setAttribute(rootNode, NODE_SCROLL_FRICTION, &item);
2654     nodeAPI->setAttribute(rootNode, NODE_SCROLL_BAR_WIDTH, &item);
2655     value[0].u32 = color;
2656     nodeAPI->setAttribute(rootNode, NODE_SCROLL_BAR_COLOR, &item);
2657 
2658     value[0].i32 = ARKUI_SCROLL_BAR_DISPLAY_MODE_AUTO;
2659     nodeAPI->setAttribute(rootNode, NODE_SCROLL_BAR_DISPLAY_MODE, &item);
2660     value[0].i32 = ARKUI_EDGE_EFFECT_NONE;
2661     nodeAPI->setAttribute(rootNode, NODE_SCROLL_EDGE_EFFECT, &item);
2662     value[0].i32 = true;
2663     nodeAPI->setAttribute(rootNode, NODE_SCROLL_ENABLE_SCROLL_INTERACTION, &item);
2664     value[0].i32 = ARKUI_AXIS_VERTICAL;
2665     nodeAPI->setAttribute(rootNode, NODE_LIST_DIRECTION, &item);
2666     value[0].i32 = ARKUI_STICKY_STYLE_NONE;
2667     nodeAPI->setAttribute(rootNode, NODE_LIST_STICKY, &item);
2668     value[0].i32 = 1;
2669     nodeAPI->setAttribute(rootNode, NODE_LIST_SPACE, &item);
2670     nodeAPI->setAttribute(rootNode, NODE_LIST_CACHED_COUNT, &item);
2671     value[0].i32 = ARKUI_LIST_ITEM_ALIGNMENT_START;
2672     nodeAPI->setAttribute(rootNode, NODE_LIST_ALIGN_LIST_ITEM, &item);
2673     value[0].i32 = 0;
2674     nodeAPI->setAttribute(rootNode, NODE_LIST_SCROLL_TO_INDEX, &item);
2675     nodeAPI->setAttribute(rootNode, NODE_LIST_INITIAL_INDEX, &item);
2676     item.object = rootNode;
2677     nodeAPI->setAttribute(groupNode, NODE_LIST_ITEM_GROUP_SET_HEADER, &item);
2678     nodeAPI->setAttribute(groupNode, NODE_LIST_ITEM_GROUP_SET_FOOTER, &item);
2679 
2680     nodeAPI->setAttribute(rootNode, NODE_SCROLL_NESTED_SCROLL, &scrollnestedItem);
2681 
2682     nodeAPI->setAttribute(rootNode, NODE_LIST_SCROLL_TO_INDEX, &scrollToIndexItem);
2683     scrollToIndex[2].i32 = ARKUI_SCROLL_ALIGNMENT_NONE;
2684     nodeAPI->setAttribute(rootNode, NODE_LIST_SCROLL_TO_INDEX, &scrollToIndexItem);
2685 
2686     nodeAPI->setAttribute(rootNode, NODE_LIST_DIVIDER, &dividerItem);
2687     nodeAPI->setAttribute(groupNode, NODE_LIST_ITEM_GROUP_SET_DIVIDER, &dividerItem);
2688 
2689     nodeAPI->setAttribute(rootNode, NODE_SCROLL_BY, &item2);
2690     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_LIST_DIRECTION), ARKUI_ERROR_CODE_NO_ERROR);
2691     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_LIST_STICKY), ARKUI_ERROR_CODE_NO_ERROR);
2692     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_LIST_SPACE), ARKUI_ERROR_CODE_NO_ERROR);
2693     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_LIST_NODE_ADAPTER), ARKUI_ERROR_CODE_NO_ERROR);
2694     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_LIST_CACHED_COUNT), ARKUI_ERROR_CODE_NO_ERROR);
2695     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_LIST_ALIGN_LIST_ITEM), ARKUI_ERROR_CODE_NO_ERROR);
2696     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_LIST_CHILDREN_MAIN_SIZE), ARKUI_ERROR_CODE_NO_ERROR);
2697     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_LIST_INITIAL_INDEX), ARKUI_ERROR_CODE_NO_ERROR);
2698     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_LIST_DIVIDER), ARKUI_ERROR_CODE_NO_ERROR);
2699     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SCROLL_FRICTION), ARKUI_ERROR_CODE_NO_ERROR);
2700     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SCROLL_BAR_DISPLAY_MODE), ARKUI_ERROR_CODE_NO_ERROR);
2701     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SCROLL_BAR_WIDTH), ARKUI_ERROR_CODE_NO_ERROR);
2702     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SCROLL_BAR_COLOR), ARKUI_ERROR_CODE_NO_ERROR);
2703     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SCROLL_EDGE_EFFECT), ARKUI_ERROR_CODE_NO_ERROR);
2704     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SCROLL_ENABLE_SCROLL_INTERACTION), ARKUI_ERROR_CODE_NO_ERROR);
2705     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SCROLL_NESTED_SCROLL), ARKUI_ERROR_CODE_NO_ERROR);
2706 
2707     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_LIST_DIRECTION), nullptr);
2708     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_LIST_STICKY), nullptr);
2709     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_LIST_SPACE), nullptr);
2710     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_LIST_NODE_ADAPTER), nullptr);
2711     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_LIST_CACHED_COUNT), nullptr);
2712     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_LIST_ALIGN_LIST_ITEM), nullptr);
2713     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_LIST_INITIAL_INDEX), nullptr);
2714     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_LIST_DIVIDER), nullptr);
2715     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SCROLL_FRICTION), nullptr);
2716     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SCROLL_BAR_DISPLAY_MODE), nullptr);
2717     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SCROLL_BAR_WIDTH), nullptr);
2718     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SCROLL_BAR_COLOR), nullptr);
2719     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SCROLL_EDGE_EFFECT), nullptr);
2720     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SCROLL_ENABLE_SCROLL_INTERACTION), nullptr);
2721     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SCROLL_NESTED_SCROLL), nullptr);
2722 
2723     EXPECT_EQ(nodeAPI->resetAttribute(childNode, NODE_LIST_ITEM_SWIPE_ACTION), ARKUI_ERROR_CODE_NO_ERROR);
2724 
2725     EXPECT_EQ(nodeAPI->resetAttribute(groupNode, NODE_LIST_ITEM_GROUP_SET_HEADER), ARKUI_ERROR_CODE_NO_ERROR);
2726     EXPECT_EQ(nodeAPI->resetAttribute(groupNode, NODE_LIST_ITEM_GROUP_SET_FOOTER), ARKUI_ERROR_CODE_NO_ERROR);
2727     EXPECT_EQ(nodeAPI->resetAttribute(groupNode, NODE_LIST_ITEM_GROUP_SET_DIVIDER), ARKUI_ERROR_CODE_NO_ERROR);
2728     EXPECT_EQ(nodeAPI->resetAttribute(groupNode, NODE_LIST_ITEM_GROUP_CHILDREN_MAIN_SIZE), ARKUI_ERROR_CODE_NO_ERROR);
2729 
2730     EXPECT_NE(nodeAPI->getAttribute(groupNode, NODE_LIST_ITEM_GROUP_SET_DIVIDER), nullptr);
2731 
2732     nodeAPI->disposeNode(rootNode);
2733     nodeAPI->disposeNode(childNode);
2734     nodeAPI->disposeNode(groupNode);
2735 }
2736 
2737 /**
2738  * @tc.name: NativeNodeTest028
2739  * @tc.desc: Test swiperNode function.
2740  * @tc.type: FUNC
2741  */
HWTEST_F(NativeNodeTest, NativeNodeTest028, TestSize.Level1)2742 HWTEST_F(NativeNodeTest, NativeNodeTest028, TestSize.Level1)
2743 {
2744     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
2745         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
2746     auto rootNode = new ArkUI_Node({ARKUI_NODE_SWIPER, nullptr});
2747     ArkUI_NumberValue value[] = {{.i32 = ARKUI_CURVE_LINEAR}};
2748     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
2749     ArkUI_NumberValue value2[] = {{.i32 = 1}, {.i32 = 1}};
2750     ArkUI_AttributeItem item2 = {value2, sizeof(value2) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
2751     nodeAPI->setAttribute(rootNode, NODE_SWIPER_CURVE, &item);
2752     value[0].i32 = ARKUI_CURVE_EASE;
2753     nodeAPI->setAttribute(rootNode, NODE_SWIPER_CURVE, &item);
2754     value[0].i32 = ARKUI_CURVE_EASE_IN;
2755     nodeAPI->setAttribute(rootNode, NODE_SWIPER_CURVE, &item);
2756     value[0].i32 = ARKUI_CURVE_EASE_OUT;
2757     nodeAPI->setAttribute(rootNode, NODE_SWIPER_CURVE, &item);
2758     value[0].i32 = ARKUI_CURVE_EASE_IN_OUT;
2759     nodeAPI->setAttribute(rootNode, NODE_SWIPER_CURVE, &item);
2760     value[0].i32 = ARKUI_CURVE_FAST_OUT_SLOW_IN;
2761     nodeAPI->setAttribute(rootNode, NODE_SWIPER_CURVE, &item);
2762     value[0].i32 = ARKUI_CURVE_LINEAR_OUT_SLOW_IN;
2763     nodeAPI->setAttribute(rootNode, NODE_SWIPER_CURVE, &item);
2764     value[0].i32 = ARKUI_CURVE_FAST_OUT_LINEAR_IN;
2765     nodeAPI->setAttribute(rootNode, NODE_SWIPER_CURVE, &item);
2766     value[0].i32 = ARKUI_CURVE_EXTREME_DECELERATION;
2767     nodeAPI->setAttribute(rootNode, NODE_SWIPER_CURVE, &item);
2768     value[0].i32 = ARKUI_CURVE_SHARP;
2769     nodeAPI->setAttribute(rootNode, NODE_SWIPER_CURVE, &item);
2770     value[0].i32 = ARKUI_CURVE_RHYTHM;
2771     nodeAPI->setAttribute(rootNode, NODE_SWIPER_CURVE, &item);
2772     value[0].i32 = ARKUI_CURVE_SMOOTH;
2773     nodeAPI->setAttribute(rootNode, NODE_SWIPER_CURVE, &item);
2774     value[0].i32 = ARKUI_CURVE_FRICTION;
2775     nodeAPI->setAttribute(rootNode, NODE_SWIPER_CURVE, &item);
2776     value[0].i32 = ARKUI_SWIPER_ARROW_HIDE;
2777     nodeAPI->setAttribute(rootNode, NODE_SWIPER_SHOW_DISPLAY_ARROW, &item);
2778     value[0].i32 = ARKUI_SWIPER_ARROW_SHOW_ON_HOVER;
2779     nodeAPI->setAttribute(rootNode, NODE_SWIPER_SHOW_DISPLAY_ARROW, &item);
2780     value[0].i32 = ARKUI_EDGE_EFFECT_SPRING;
2781     nodeAPI->setAttribute(rootNode, NODE_SWIPER_EDGE_EFFECT_MODE, &item);
2782     value[0].i32 = ARKUI_SWIPER_NESTED_SRCOLL_SELF_ONLY;
2783     nodeAPI->setAttribute(rootNode, NODE_SWIPER_NESTED_SCROLL, &item);
2784     value[0].i32 = true;
2785     nodeAPI->setAttribute(rootNode, NODE_SWIPER_LOOP, &item);
2786     nodeAPI->setAttribute(rootNode, NODE_SWIPER_AUTO_PLAY, &item);
2787     nodeAPI->setAttribute(rootNode, NODE_SWIPER_SHOW_INDICATOR, &item);
2788     nodeAPI->setAttribute(rootNode, NODE_SWIPER_VERTICAL, &item);
2789     nodeAPI->setAttribute(rootNode, NODE_SWIPER_INDEX, &item);
2790     nodeAPI->setAttribute(rootNode, NODE_SWIPER_DISPLAY_COUNT, &item);
2791     nodeAPI->setAttribute(rootNode, NODE_SWIPER_DISABLE_SWIPE, &item);
2792     nodeAPI->setAttribute(rootNode, NODE_SWIPER_CACHED_COUNT, &item);
2793     nodeAPI->setAttribute(rootNode, NODE_SWIPER_SWIPE_TO_INDEX, &item);
2794     nodeAPI->setAttribute(rootNode, NODE_SWIPER_INDICATOR_INTERACTIVE, &item);
2795 
2796     value[0].f32 = 10.0f;
2797     nodeAPI->setAttribute(rootNode, NODE_SWIPER_INTERVAL, &item);
2798     nodeAPI->setAttribute(rootNode, NODE_SWIPER_DURATION, &item);
2799     nodeAPI->setAttribute(rootNode, NODE_SWIPER_ITEM_SPACE, &item);
2800     nodeAPI->setAttribute(rootNode, NODE_SWIPER_PREV_MARGIN, &item);
2801     nodeAPI->setAttribute(rootNode, NODE_SWIPER_NEXT_MARGIN, &item);
2802 
2803     nodeAPI->setAttribute(rootNode, NODE_SWIPER_SWIPE_TO_INDEX, &item2);
2804     value2[1].i32 = -1;
2805     nodeAPI->setAttribute(rootNode, NODE_SWIPER_SWIPE_TO_INDEX, &item2);
2806 
2807     value2[0].f32 = 10.0f;
2808     value2[1].i32 = 1;
2809     nodeAPI->setAttribute(rootNode, NODE_SWIPER_PREV_MARGIN, &item);
2810     nodeAPI->setAttribute(rootNode, NODE_SWIPER_NEXT_MARGIN, &item);
2811     value2[1].i32 = -1;
2812     nodeAPI->setAttribute(rootNode, NODE_SWIPER_PREV_MARGIN, &item);
2813     nodeAPI->setAttribute(rootNode, NODE_SWIPER_NEXT_MARGIN, &item);
2814 
2815     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SWIPER_LOOP), ARKUI_ERROR_CODE_NO_ERROR);
2816     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SWIPER_AUTO_PLAY), ARKUI_ERROR_CODE_NO_ERROR);
2817     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SWIPER_SHOW_INDICATOR), ARKUI_ERROR_CODE_NO_ERROR);
2818     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SWIPER_INTERVAL), ARKUI_ERROR_CODE_NO_ERROR);
2819     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SWIPER_VERTICAL), ARKUI_ERROR_CODE_NO_ERROR);
2820     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SWIPER_DURATION), ARKUI_ERROR_CODE_NO_ERROR);
2821     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SWIPER_CURVE), ARKUI_ERROR_CODE_NO_ERROR);
2822     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SWIPER_ITEM_SPACE), ARKUI_ERROR_CODE_NO_ERROR);
2823     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SWIPER_INDEX), ARKUI_ERROR_CODE_NO_ERROR);
2824     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SWIPER_DISPLAY_COUNT), ARKUI_ERROR_CODE_NO_ERROR);
2825     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SWIPER_DISABLE_SWIPE), ARKUI_ERROR_CODE_NO_ERROR);
2826     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SWIPER_SHOW_DISPLAY_ARROW), ARKUI_ERROR_CODE_NO_ERROR);
2827     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SWIPER_EDGE_EFFECT_MODE), ARKUI_ERROR_CODE_NO_ERROR);
2828     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SWIPER_NODE_ADAPTER), ARKUI_ERROR_CODE_NO_ERROR);
2829     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SWIPER_CACHED_COUNT), ARKUI_ERROR_CODE_NO_ERROR);
2830     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SWIPER_PREV_MARGIN), ARKUI_ERROR_CODE_NO_ERROR);
2831     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SWIPER_NEXT_MARGIN), ARKUI_ERROR_CODE_NO_ERROR);
2832     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SWIPER_INDICATOR), ARKUI_ERROR_CODE_NO_ERROR);
2833     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SWIPER_NESTED_SCROLL), ARKUI_ERROR_CODE_NO_ERROR);
2834     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SWIPER_INDICATOR_INTERACTIVE), ARKUI_ERROR_CODE_NO_ERROR);
2835 
2836     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SWIPER_LOOP), nullptr);
2837     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SWIPER_AUTO_PLAY), nullptr);
2838     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SWIPER_SHOW_INDICATOR), nullptr);
2839     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SWIPER_INTERVAL), nullptr);
2840     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SWIPER_VERTICAL), nullptr);
2841     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SWIPER_DURATION), nullptr);
2842     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SWIPER_CURVE), nullptr);
2843     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SWIPER_ITEM_SPACE), nullptr);
2844     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SWIPER_INDEX), nullptr);
2845     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SWIPER_DISPLAY_COUNT), nullptr);
2846     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SWIPER_DISABLE_SWIPE), nullptr);
2847     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SWIPER_SHOW_DISPLAY_ARROW), nullptr);
2848     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SWIPER_EDGE_EFFECT_MODE), nullptr);
2849     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SWIPER_NODE_ADAPTER), nullptr);
2850     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SWIPER_CACHED_COUNT), nullptr);
2851     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SWIPER_PREV_MARGIN), nullptr);
2852     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SWIPER_NEXT_MARGIN), nullptr);
2853     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SWIPER_INDICATOR), nullptr);
2854     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SWIPER_NESTED_SCROLL), nullptr);
2855     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SWIPER_INDICATOR_INTERACTIVE), nullptr);
2856     nodeAPI->disposeNode(rootNode);
2857 }
2858 
2859 /**
2860  * @tc.name: NativeNodeTest029
2861  * @tc.desc: Test columnNode function.
2862  * @tc.type: FUNC
2863  */
HWTEST_F(NativeNodeTest, NativeNodeTest029, TestSize.Level1)2864 HWTEST_F(NativeNodeTest, NativeNodeTest029, TestSize.Level1)
2865 {
2866     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
2867         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
2868     auto rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
2869     ASSERT_NE(rootNode, nullptr);
2870     ArkUI_NumberValue value[] = {{.i32 = ARKUI_HORIZONTAL_ALIGNMENT_CENTER}};
2871     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
2872     nodeAPI->setAttribute(rootNode, NODE_COLUMN_ALIGN_ITEMS, &item);
2873     value[0].i32 = ARKUI_FLEX_ALIGNMENT_START;
2874     nodeAPI->setAttribute(rootNode, NODE_COLUMN_JUSTIFY_CONTENT, &item);
2875     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_COLUMN_ALIGN_ITEMS), ARKUI_ERROR_CODE_NO_ERROR);
2876     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_COLUMN_JUSTIFY_CONTENT), ARKUI_ERROR_CODE_NO_ERROR);
2877 
2878     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_COLUMN_ALIGN_ITEMS), nullptr);
2879     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_COLUMN_JUSTIFY_CONTENT), nullptr);
2880     nodeAPI->disposeNode(rootNode);
2881 }
2882 
2883 /**
2884  * @tc.name: NativeNodeTest030
2885  * @tc.desc: Test rowNode function.
2886  * @tc.type: FUNC
2887  */
HWTEST_F(NativeNodeTest, NativeNodeTest030, TestSize.Level1)2888 HWTEST_F(NativeNodeTest, NativeNodeTest030, TestSize.Level1)
2889 {
2890     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
2891         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
2892     auto rootNode = nodeAPI->createNode(ARKUI_NODE_ROW);
2893     ASSERT_NE(rootNode, nullptr);
2894     ArkUI_NumberValue value[] = {{.i32 = ARKUI_VERTICAL_ALIGNMENT_CENTER}};
2895     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
2896     nodeAPI->setAttribute(rootNode, NODE_ROW_ALIGN_ITEMS, &item);
2897     value[0].i32 = ARKUI_FLEX_ALIGNMENT_START;
2898     nodeAPI->setAttribute(rootNode, NODE_ROW_JUSTIFY_CONTENT, &item);
2899     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_ROW_ALIGN_ITEMS), ARKUI_ERROR_CODE_NO_ERROR);
2900     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_ROW_JUSTIFY_CONTENT), ARKUI_ERROR_CODE_NO_ERROR);
2901 
2902     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_ROW_ALIGN_ITEMS), nullptr);
2903     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_ROW_JUSTIFY_CONTENT), nullptr);
2904     nodeAPI->disposeNode(rootNode);
2905 }
2906 
2907 /**
2908  * @tc.name: NativeNodeTest031
2909  * @tc.desc: Test flexNode function.
2910  * @tc.type: FUNC
2911  */
HWTEST_F(NativeNodeTest, NativeNodeTest031, TestSize.Level1)2912 HWTEST_F(NativeNodeTest, NativeNodeTest031, TestSize.Level1)
2913 {
2914     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
2915         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
2916     auto rootNode = nodeAPI->createNode(ARKUI_NODE_FLEX);
2917     auto childNode = nodeAPI->createNode(ARKUI_NODE_STACK);
2918     ASSERT_NE(rootNode, nullptr);
2919     ASSERT_NE(childNode, nullptr);
2920     nodeAPI->addChild(rootNode, childNode);
2921 
2922     ArkUI_NumberValue value0[] = {};
2923     ArkUI_AttributeItem item0 = {value0, 0, nullptr, nullptr};
2924     int32_t negativeEnum = -1;
2925     ArkUI_NumberValue valueEnum[] = {{.i32 = negativeEnum}};
2926     ArkUI_AttributeItem itemEnum = {valueEnum, 1, nullptr, nullptr};
2927     float negativeFloat = -1.0f;
2928     ArkUI_NumberValue valueFloat[] = {{.f32 = negativeFloat}};
2929     ArkUI_AttributeItem itemFloat = {valueFloat, sizeof(valueFloat) / sizeof(ArkUI_NumberValue)};
2930     ArkUI_NumberValue value[] = {{.i32 = ARKUI_ITEM_ALIGNMENT_AUTO}};
2931     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
2932     EXPECT_EQ(nodeAPI->setAttribute(childNode, NODE_ALIGN_SELF, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
2933     EXPECT_EQ(nodeAPI->setAttribute(childNode, NODE_ALIGN_SELF, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
2934     EXPECT_EQ(nodeAPI->setAttribute(childNode, NODE_ALIGN_SELF, &item), ARKUI_ERROR_CODE_NO_ERROR);
2935     auto alignSelfVal = nodeAPI->getAttribute(childNode, NODE_ALIGN_SELF);
2936     EXPECT_EQ(alignSelfVal->value[0].i32, static_cast<int32_t>(ARKUI_ITEM_ALIGNMENT_AUTO));
2937 
2938     EXPECT_EQ(nodeAPI->setAttribute(childNode, NODE_FLEX_GROW, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
2939     EXPECT_EQ(nodeAPI->setAttribute(childNode, NODE_FLEX_GROW, &itemFloat), ARKUI_ERROR_CODE_PARAM_INVALID);
2940     float flexGrowInput = 2.0f;
2941     value[0].f32 = flexGrowInput;
2942     EXPECT_EQ(nodeAPI->setAttribute(childNode, NODE_FLEX_GROW, &item), ARKUI_ERROR_CODE_NO_ERROR);
2943     auto flexGrowVal = nodeAPI->getAttribute(childNode, NODE_FLEX_GROW);
2944     EXPECT_EQ(flexGrowVal->value[0].f32, flexGrowInput);
2945 
2946     EXPECT_EQ(nodeAPI->setAttribute(childNode, NODE_FLEX_SHRINK, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
2947     EXPECT_EQ(nodeAPI->setAttribute(childNode, NODE_FLEX_SHRINK, &itemFloat), ARKUI_ERROR_CODE_PARAM_INVALID);
2948     float flexShrinkInput = 0.0f;
2949     value[0].f32 = flexShrinkInput;
2950     EXPECT_EQ(nodeAPI->setAttribute(childNode, NODE_FLEX_SHRINK, &item), ARKUI_ERROR_CODE_NO_ERROR);
2951     auto flexShrinkVal = nodeAPI->getAttribute(childNode, NODE_FLEX_SHRINK);
2952     EXPECT_EQ(flexShrinkVal->value[0].f32, flexShrinkInput);
2953 
2954     EXPECT_EQ(nodeAPI->setAttribute(childNode, NODE_FLEX_BASIS, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
2955     EXPECT_EQ(nodeAPI->setAttribute(childNode, NODE_FLEX_BASIS, &itemFloat), ARKUI_ERROR_CODE_PARAM_INVALID);
2956     float flexBasisInput = 100.0f;
2957     value[0].f32 = flexBasisInput;
2958     EXPECT_EQ(nodeAPI->setAttribute(childNode, NODE_FLEX_BASIS, &item), ARKUI_ERROR_CODE_NO_ERROR);
2959     auto flexBasisVal = nodeAPI->getAttribute(childNode, NODE_FLEX_BASIS);
2960     EXPECT_EQ(flexBasisVal->value[0].f32, flexBasisInput);
2961 
2962     ArkUI_NumberValue flexOptVal[] = {{.i32 = ARKUI_FLEX_DIRECTION_ROW}, {.i32 = ARKUI_FLEX_WRAP_NO_WRAP},
2963         {.i32 = ARKUI_FLEX_ALIGNMENT_START}, {.i32 = ARKUI_ITEM_ALIGNMENT_START}, {.i32 = ARKUI_FLEX_ALIGNMENT_START}};
2964     ArkUI_AttributeItem flexOptItem = {flexOptVal, sizeof(flexOptVal) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
2965     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_FLEX_OPTION, &flexOptItem), ARKUI_ERROR_CODE_NO_ERROR);
2966     auto flexOptResult = nodeAPI->getAttribute(rootNode, NODE_FLEX_OPTION);
2967     EXPECT_EQ(flexOptResult->value[0].i32, static_cast<int32_t>(ARKUI_FLEX_DIRECTION_ROW));
2968 
2969     int32_t abnormalVal = 10;
2970     flexOptVal[4].i32 = abnormalVal;
2971     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_FLEX_OPTION, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
2972     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_FLEX_OPTION, &flexOptItem), ARKUI_ERROR_CODE_PARAM_INVALID);
2973     flexOptVal[3].i32 = abnormalVal;
2974     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_FLEX_OPTION, &flexOptItem), ARKUI_ERROR_CODE_PARAM_INVALID);
2975     flexOptVal[2].i32 = abnormalVal;
2976     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_FLEX_OPTION, &flexOptItem), ARKUI_ERROR_CODE_PARAM_INVALID);
2977     flexOptVal[1].i32 = abnormalVal;
2978     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_FLEX_OPTION, &flexOptItem), ARKUI_ERROR_CODE_PARAM_INVALID);
2979     flexOptVal[0].i32 = abnormalVal;
2980     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_FLEX_OPTION, &flexOptItem), ARKUI_ERROR_CODE_PARAM_INVALID);
2981     flexOptItem.size = -1;
2982     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_FLEX_OPTION, &flexOptItem), ARKUI_ERROR_CODE_NO_ERROR);
2983 
2984     EXPECT_EQ(nodeAPI->resetAttribute(childNode, NODE_ALIGN_SELF), ARKUI_ERROR_CODE_NO_ERROR);
2985     EXPECT_EQ(nodeAPI->resetAttribute(childNode, NODE_FLEX_GROW), ARKUI_ERROR_CODE_NO_ERROR);
2986     EXPECT_EQ(nodeAPI->resetAttribute(childNode, NODE_FLEX_SHRINK), ARKUI_ERROR_CODE_NO_ERROR);
2987     EXPECT_EQ(nodeAPI->resetAttribute(childNode, NODE_FLEX_BASIS), ARKUI_ERROR_CODE_NO_ERROR);
2988     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_FLEX_OPTION), ARKUI_ERROR_CODE_NO_ERROR);
2989     nodeAPI->disposeNode(childNode);
2990     nodeAPI->disposeNode(rootNode);
2991 }
2992 
2993 /**
2994  * @tc.name: NativeNodeTest032
2995  * @tc.desc: Test refreshNode function.
2996  * @tc.type: FUNC
2997  */
HWTEST_F(NativeNodeTest, NativeNodeTest032, TestSize.Level1)2998 HWTEST_F(NativeNodeTest, NativeNodeTest032, TestSize.Level1)
2999 {
3000     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
3001         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
3002     auto rootNode = new ArkUI_Node({ARKUI_NODE_REFRESH, nullptr});
3003     ASSERT_NE(rootNode, nullptr);
3004     ArkUI_NumberValue value[] = {{.i32 = true}};
3005     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
3006     nodeAPI->setAttribute(rootNode, NODE_REFRESH_REFRESHING, &item);
3007     nodeAPI->setAttribute(rootNode, NODE_REFRESH_PULL_DOWN_RATIO, &item);
3008     value[0].f32 = 0.5f;
3009     nodeAPI->setAttribute(rootNode, NODE_REFRESH_PULL_DOWN_RATIO, &item);
3010     nodeAPI->setAttribute(rootNode, NODE_REFRESH_OFFSET, &item);
3011     item.object = rootNode;
3012     nodeAPI->setAttribute(rootNode, NODE_REFRESH_CONTENT, &item);
3013     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_REFRESH_CONTENT), ARKUI_ERROR_CODE_NO_ERROR);
3014     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_REFRESH_PULL_DOWN_RATIO), ARKUI_ERROR_CODE_NO_ERROR);
3015     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_REFRESH_OFFSET), ARKUI_ERROR_CODE_NO_ERROR);
3016     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_REFRESH_PULL_TO_REFRESH), ARKUI_ERROR_CODE_NO_ERROR);
3017 
3018     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_REFRESH_REFRESHING), nullptr);
3019     EXPECT_EQ(nodeAPI->getAttribute(rootNode, NODE_REFRESH_CONTENT), nullptr);
3020     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_REFRESH_PULL_DOWN_RATIO), nullptr);
3021     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_REFRESH_OFFSET), nullptr);
3022     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_REFRESH_PULL_TO_REFRESH), nullptr);
3023     nodeAPI->disposeNode(rootNode);
3024 }
3025 
3026 /**
3027  * @tc.name: NativeNodeTest033
3028  * @tc.desc: Test waterflowNode function.
3029  * @tc.type: FUNC
3030  */
HWTEST_F(NativeNodeTest, NativeNodeTest033, TestSize.Level1)3031 HWTEST_F(NativeNodeTest, NativeNodeTest033, TestSize.Level1)
3032 {
3033     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
3034         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
3035     auto rootNode = new ArkUI_Node({ARKUI_NODE_WATER_FLOW, nullptr});
3036     float distance = 10.0f;
3037     uint32_t color = 0xFFFF0000;
3038     ArkUI_NumberValue value[] = {{.f32 = distance}};
3039     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue)};
3040     ArkUI_NumberValue value2[] = {{.f32 = distance}, {.f32 = distance}};
3041     ArkUI_AttributeItem item2 = {value2, sizeof(value2) / sizeof(ArkUI_NumberValue)};
3042     ArkUI_NumberValue scrollnested[] = {{.i32 = ARKUI_SCROLL_NESTED_MODE_SELF_ONLY},
3043         {.i32 = ARKUI_SCROLL_NESTED_MODE_SELF_ONLY}};
3044     ArkUI_AttributeItem scrollnestedItem = {scrollnested, sizeof(scrollnested) / sizeof(ArkUI_NumberValue)};
3045     ArkUI_NumberValue constraintSize[] = {{.f32 = distance}, {.f32 = distance}, {.f32 = distance}, {.f32 = distance}};
3046     ArkUI_AttributeItem constraintSizeItem = {constraintSize, sizeof(constraintSize) / sizeof(ArkUI_NumberValue)};
3047     ArkUI_NumberValue indexValue[] = {{.i32 = 0}, {.i32 = 0}, {.i32 = ARKUI_SCROLL_ALIGNMENT_START}};
3048     ArkUI_AttributeItem indexItem = {indexValue, sizeof(indexValue) / sizeof(ArkUI_NumberValue)};
3049     nodeAPI->setAttribute(rootNode, NODE_SCROLL_FRICTION, &item);
3050     nodeAPI->setAttribute(rootNode, NODE_SCROLL_BAR_WIDTH, &item);
3051     nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_COLUMN_GAP, &item);
3052     nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_ROW_GAP, &item);
3053     value[0].u32 = color;
3054     nodeAPI->setAttribute(rootNode, NODE_SCROLL_BAR_COLOR, &item);
3055 
3056     value[0].i32 = ARKUI_SCROLL_BAR_DISPLAY_MODE_AUTO;
3057     nodeAPI->setAttribute(rootNode, NODE_SCROLL_BAR_DISPLAY_MODE, &item);
3058     value[0].i32 = ARKUI_EDGE_EFFECT_NONE;
3059     nodeAPI->setAttribute(rootNode, NODE_SCROLL_EDGE_EFFECT, &item);
3060     value[0].i32 = ARKUI_FLEX_DIRECTION_ROW;
3061     nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_LAYOUT_DIRECTION, &item);
3062     value[0].i32 = true;
3063     nodeAPI->setAttribute(rootNode, NODE_SCROLL_ENABLE_SCROLL_INTERACTION, &item);
3064     nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_CACHED_COUNT, &item);
3065     nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_SCROLL_TO_INDEX, &item);
3066 
3067     item.string = "test";
3068     nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_COLUMN_TEMPLATE, &item);
3069     nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_ROW_TEMPLATE, &item);
3070 
3071     item.object = rootNode;
3072     nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_FOOTER, &item);
3073 
3074     nodeAPI->setAttribute(rootNode, NODE_SCROLL_NESTED_SCROLL, &scrollnestedItem);
3075     nodeAPI->setAttribute(rootNode, NODE_SCROLL_BY, &item2);
3076     nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_ITEM_CONSTRAINT_SIZE, &constraintSizeItem);
3077     nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_SCROLL_TO_INDEX, &indexItem);
3078     indexValue[2].i32 = ARKUI_SCROLL_ALIGNMENT_NONE;
3079     nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_SCROLL_TO_INDEX, &indexItem);
3080     indexValue[2].i32 = -1;
3081     indexValue[1].i32 = -1;
3082     nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_SCROLL_TO_INDEX, &indexItem);
3083     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_WATER_FLOW_LAYOUT_DIRECTION), ARKUI_ERROR_CODE_NO_ERROR);
3084     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_WATER_FLOW_COLUMN_TEMPLATE), ARKUI_ERROR_CODE_NO_ERROR);
3085     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_WATER_FLOW_ROW_TEMPLATE), ARKUI_ERROR_CODE_NO_ERROR);
3086     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_WATER_FLOW_COLUMN_GAP), ARKUI_ERROR_CODE_NO_ERROR);
3087     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_WATER_FLOW_ROW_GAP), ARKUI_ERROR_CODE_NO_ERROR);
3088     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_WATER_FLOW_SECTION_OPTION), ARKUI_ERROR_CODE_NO_ERROR);
3089     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_WATER_FLOW_NODE_ADAPTER), ARKUI_ERROR_CODE_NO_ERROR);
3090     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_WATER_FLOW_CACHED_COUNT), ARKUI_ERROR_CODE_NO_ERROR);
3091     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_WATER_FLOW_FOOTER), ARKUI_ERROR_CODE_NO_ERROR);
3092     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_WATER_FLOW_ITEM_CONSTRAINT_SIZE), ARKUI_ERROR_CODE_NO_ERROR);
3093     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SCROLL_FRICTION), ARKUI_ERROR_CODE_NO_ERROR);
3094     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SCROLL_BAR_DISPLAY_MODE), ARKUI_ERROR_CODE_NO_ERROR);
3095     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SCROLL_BAR_WIDTH), ARKUI_ERROR_CODE_NO_ERROR);
3096     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SCROLL_BAR_COLOR), ARKUI_ERROR_CODE_NO_ERROR);
3097     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SCROLL_EDGE_EFFECT), ARKUI_ERROR_CODE_NO_ERROR);
3098     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SCROLL_ENABLE_SCROLL_INTERACTION), ARKUI_ERROR_CODE_NO_ERROR);
3099     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_SCROLL_NESTED_SCROLL), ARKUI_ERROR_CODE_NO_ERROR);
3100 
3101     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_WATER_FLOW_LAYOUT_DIRECTION), nullptr);
3102     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_WATER_FLOW_COLUMN_TEMPLATE), nullptr);
3103     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_WATER_FLOW_ROW_TEMPLATE), nullptr);
3104     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_WATER_FLOW_COLUMN_GAP), nullptr);
3105     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_WATER_FLOW_ROW_GAP), nullptr);
3106     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_WATER_FLOW_NODE_ADAPTER), nullptr);
3107     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_WATER_FLOW_CACHED_COUNT), nullptr);
3108     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_WATER_FLOW_ITEM_CONSTRAINT_SIZE), nullptr);
3109     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SCROLL_FRICTION), nullptr);
3110     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SCROLL_BAR_DISPLAY_MODE), nullptr);
3111     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SCROLL_BAR_WIDTH), nullptr);
3112     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SCROLL_BAR_COLOR), nullptr);
3113     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SCROLL_EDGE_EFFECT), nullptr);
3114     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SCROLL_ENABLE_SCROLL_INTERACTION), nullptr);
3115     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_SCROLL_NESTED_SCROLL), nullptr);
3116     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_WATER_FLOW_SECTION_OPTION), nullptr);
3117     nodeAPI->disposeNode(rootNode);
3118 }
3119 
3120 /**
3121  * @tc.name: NativeNodeTest034
3122  * @tc.desc: Test gridNode function.
3123  * @tc.type: FUNC
3124  */
HWTEST_F(NativeNodeTest, NativeNodeTest034, TestSize.Level1)3125 HWTEST_F(NativeNodeTest, NativeNodeTest034, TestSize.Level1)
3126 {
3127     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
3128         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
3129     auto rootNode = nodeAPI->createNode(ARKUI_NODE_GRID);
3130     ASSERT_NE(rootNode, nullptr);
3131     ArkUI_NumberValue value[] = {{.f32 = 1.0f}};
3132     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue), "test"};
3133     nodeAPI->setAttribute(rootNode, NODE_GRID_COLUMN_TEMPLATE, &item);
3134     nodeAPI->setAttribute(rootNode, NODE_GRID_ROW_TEMPLATE, &item);
3135     nodeAPI->setAttribute(rootNode, NODE_GRID_COLUMN_GAP, &item);
3136     nodeAPI->setAttribute(rootNode, NODE_GRID_ROW_GAP, &item);
3137     value[0].i32 = 1;
3138     nodeAPI->setAttribute(rootNode, NODE_GRID_CACHED_COUNT, &item);
3139     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_GRID_COLUMN_TEMPLATE), ARKUI_ERROR_CODE_NO_ERROR);
3140     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_GRID_ROW_TEMPLATE), ARKUI_ERROR_CODE_NO_ERROR);
3141     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_GRID_COLUMN_GAP), ARKUI_ERROR_CODE_NO_ERROR);
3142     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_GRID_ROW_GAP), ARKUI_ERROR_CODE_NO_ERROR);
3143     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_GRID_NODE_ADAPTER), ARKUI_ERROR_CODE_NO_ERROR);
3144     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_GRID_CACHED_COUNT), ARKUI_ERROR_CODE_NO_ERROR);
3145 
3146     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_GRID_COLUMN_TEMPLATE), nullptr);
3147     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_GRID_ROW_TEMPLATE), nullptr);
3148     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_GRID_COLUMN_GAP), nullptr);
3149     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_GRID_ROW_GAP), nullptr);
3150     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_GRID_NODE_ADAPTER), nullptr);
3151     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_GRID_CACHED_COUNT), nullptr);
3152     nodeAPI->disposeNode(rootNode);
3153 }
3154 
3155 /**
3156  * @tc.name: NativeNodeTest035
3157  * @tc.desc: Test relativeContainerNode function.
3158  * @tc.type: FUNC
3159  */
HWTEST_F(NativeNodeTest, NativeNodeTest035, TestSize.Level1)3160 HWTEST_F(NativeNodeTest, NativeNodeTest035, TestSize.Level1)
3161 {
3162     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
3163         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
3164     auto rootNode = new ArkUI_Node({ARKUI_NODE_RELATIVE_CONTAINER, nullptr});
3165     ASSERT_NE(rootNode, nullptr);
3166 
3167     auto alignRules = OH_ArkUI_AlignmentRuleOption_Create();
3168     float baisVal = 10.0f;
3169     ArkUI_AttributeItem alignRulesItem = {.size = 0, .object = alignRules};
3170     nodeAPI->setAttribute(rootNode, NODE_ALIGN_RULES, &alignRulesItem);
3171     OH_ArkUI_AlignmentRuleOption_SetStart(nullptr, nullptr, ARKUI_HORIZONTAL_ALIGNMENT_START);
3172     OH_ArkUI_AlignmentRuleOption_SetStart(alignRules, nullptr, ARKUI_HORIZONTAL_ALIGNMENT_START);
3173     EXPECT_EQ(OH_ArkUI_AlignmentRuleOption_GetStartId(alignRules), nullptr);
3174     EXPECT_EQ(OH_ArkUI_AlignmentRuleOption_GetStartAlignment(alignRules), static_cast<ArkUI_HorizontalAlignment>(-1));
3175     OH_ArkUI_AlignmentRuleOption_SetStart(alignRules, "__container__", ARKUI_HORIZONTAL_ALIGNMENT_START);
3176     OH_ArkUI_AlignmentRuleOption_SetTop(nullptr, nullptr, ARKUI_VERTICAL_ALIGNMENT_TOP);
3177     OH_ArkUI_AlignmentRuleOption_SetTop(alignRules, nullptr, ARKUI_VERTICAL_ALIGNMENT_TOP);
3178     EXPECT_EQ(OH_ArkUI_AlignmentRuleOption_GetTopId(alignRules), nullptr);
3179     EXPECT_EQ(OH_ArkUI_AlignmentRuleOption_GetTopAlignment(alignRules), static_cast<ArkUI_VerticalAlignment>(-1));
3180     OH_ArkUI_AlignmentRuleOption_SetTop(alignRules, "__container__", ARKUI_VERTICAL_ALIGNMENT_TOP);
3181     OH_ArkUI_AlignmentRuleOption_SetEnd(nullptr, nullptr, ARKUI_HORIZONTAL_ALIGNMENT_END);
3182     OH_ArkUI_AlignmentRuleOption_SetEnd(alignRules, nullptr, ARKUI_HORIZONTAL_ALIGNMENT_END);
3183     EXPECT_EQ(OH_ArkUI_AlignmentRuleOption_GetEndId(alignRules), nullptr);
3184     EXPECT_EQ(OH_ArkUI_AlignmentRuleOption_GetEndAlignment(alignRules), static_cast<ArkUI_HorizontalAlignment>(-1));
3185     OH_ArkUI_AlignmentRuleOption_SetEnd(alignRules, "__container__", ARKUI_HORIZONTAL_ALIGNMENT_END);
3186     OH_ArkUI_AlignmentRuleOption_SetBottom(nullptr, nullptr, ARKUI_VERTICAL_ALIGNMENT_BOTTOM);
3187     OH_ArkUI_AlignmentRuleOption_SetBottom(alignRules, nullptr, ARKUI_VERTICAL_ALIGNMENT_BOTTOM);
3188     EXPECT_EQ(OH_ArkUI_AlignmentRuleOption_GetBottomId(alignRules), nullptr);
3189     EXPECT_EQ(OH_ArkUI_AlignmentRuleOption_GetBottomAlignment(alignRules), static_cast<ArkUI_VerticalAlignment>(-1));
3190     OH_ArkUI_AlignmentRuleOption_SetBottom(alignRules, "__container__", ARKUI_VERTICAL_ALIGNMENT_BOTTOM);
3191     OH_ArkUI_AlignmentRuleOption_SetCenterHorizontal(nullptr, nullptr, ARKUI_HORIZONTAL_ALIGNMENT_CENTER);
3192     OH_ArkUI_AlignmentRuleOption_SetCenterHorizontal(alignRules, nullptr, ARKUI_HORIZONTAL_ALIGNMENT_CENTER);
3193     EXPECT_EQ(OH_ArkUI_AlignmentRuleOption_GetCenterIdHorizontal(alignRules), nullptr);
3194     EXPECT_EQ(OH_ArkUI_AlignmentRuleOption_GetCenterAlignmentHorizontal(alignRules),
3195         static_cast<ArkUI_HorizontalAlignment>(-1));
3196     OH_ArkUI_AlignmentRuleOption_SetCenterHorizontal(alignRules, "__container__", ARKUI_HORIZONTAL_ALIGNMENT_CENTER);
3197     OH_ArkUI_AlignmentRuleOption_SetCenterVertical(nullptr, nullptr, ARKUI_VERTICAL_ALIGNMENT_CENTER);
3198     OH_ArkUI_AlignmentRuleOption_SetCenterVertical(alignRules, nullptr, ARKUI_VERTICAL_ALIGNMENT_CENTER);
3199     EXPECT_EQ(OH_ArkUI_AlignmentRuleOption_GetCenterIdVertical(alignRules), nullptr);
3200     EXPECT_EQ(OH_ArkUI_AlignmentRuleOption_GetCenterAlignmentVertical(alignRules),
3201         static_cast<ArkUI_VerticalAlignment>(-1));
3202     OH_ArkUI_AlignmentRuleOption_SetCenterVertical(alignRules, "__container__", ARKUI_VERTICAL_ALIGNMENT_CENTER);
3203     OH_ArkUI_AlignmentRuleOption_SetBiasHorizontal(nullptr, baisVal);
3204     OH_ArkUI_AlignmentRuleOption_SetBiasHorizontal(alignRules, baisVal);
3205     OH_ArkUI_AlignmentRuleOption_SetBiasVertical(nullptr, baisVal);
3206     OH_ArkUI_AlignmentRuleOption_SetBiasVertical(alignRules, baisVal);
3207     alignRulesItem.object = alignRules;
3208     nodeAPI->setAttribute(rootNode, NODE_ALIGN_RULES, &alignRulesItem);
3209     auto alignRulesGetVal = nodeAPI->getAttribute(rootNode, NODE_ALIGN_RULES);
3210     ASSERT_NE(alignRulesGetVal, nullptr);
3211     OH_ArkUI_AlignmentRuleOption_GetStartId(alignRules);
3212     OH_ArkUI_AlignmentRuleOption_GetStartAlignment(alignRules);
3213     OH_ArkUI_AlignmentRuleOption_GetEndId(alignRules);
3214     OH_ArkUI_AlignmentRuleOption_GetEndAlignment(alignRules);
3215     OH_ArkUI_AlignmentRuleOption_GetCenterIdHorizontal(alignRules);
3216     OH_ArkUI_AlignmentRuleOption_GetCenterAlignmentHorizontal(alignRules);
3217     OH_ArkUI_AlignmentRuleOption_GetTopId(alignRules);
3218     OH_ArkUI_AlignmentRuleOption_GetTopAlignment(alignRules);
3219     OH_ArkUI_AlignmentRuleOption_GetBottomId(alignRules);
3220     OH_ArkUI_AlignmentRuleOption_GetBottomAlignment(alignRules);
3221     OH_ArkUI_AlignmentRuleOption_GetCenterIdVertical(alignRules);
3222     OH_ArkUI_AlignmentRuleOption_GetCenterAlignmentVertical(alignRules);
3223     OH_ArkUI_AlignmentRuleOption_GetBiasHorizontal(alignRules);
3224     OH_ArkUI_AlignmentRuleOption_GetBiasVertical(alignRules);
3225 
3226     EXPECT_EQ(OH_ArkUI_AlignmentRuleOption_GetStartId(nullptr), nullptr);
3227     EXPECT_EQ(OH_ArkUI_AlignmentRuleOption_GetStartAlignment(nullptr), static_cast<ArkUI_HorizontalAlignment>(-1));
3228     EXPECT_EQ(OH_ArkUI_AlignmentRuleOption_GetEndId(nullptr), nullptr);
3229     EXPECT_EQ(OH_ArkUI_AlignmentRuleOption_GetEndAlignment(nullptr), static_cast<ArkUI_HorizontalAlignment>(-1));
3230     EXPECT_EQ(OH_ArkUI_AlignmentRuleOption_GetCenterIdHorizontal(nullptr), nullptr);
3231     EXPECT_EQ(OH_ArkUI_AlignmentRuleOption_GetCenterAlignmentHorizontal(nullptr),
3232         static_cast<ArkUI_HorizontalAlignment>(-1));
3233     EXPECT_EQ(OH_ArkUI_AlignmentRuleOption_GetTopId(nullptr), nullptr);
3234     EXPECT_EQ(OH_ArkUI_AlignmentRuleOption_GetTopAlignment(nullptr), static_cast<ArkUI_VerticalAlignment>(-1));
3235     EXPECT_EQ(OH_ArkUI_AlignmentRuleOption_GetBottomId(nullptr), nullptr);
3236     EXPECT_EQ(OH_ArkUI_AlignmentRuleOption_GetBottomAlignment(nullptr), static_cast<ArkUI_VerticalAlignment>(-1));
3237     EXPECT_EQ(OH_ArkUI_AlignmentRuleOption_GetCenterIdVertical(nullptr), nullptr);
3238     EXPECT_EQ(OH_ArkUI_AlignmentRuleOption_GetCenterAlignmentVertical(nullptr),
3239         static_cast<ArkUI_VerticalAlignment>(-1));
3240     EXPECT_EQ(OH_ArkUI_AlignmentRuleOption_GetBiasHorizontal(nullptr), -1.0f);
3241     EXPECT_EQ(OH_ArkUI_AlignmentRuleOption_GetBiasVertical(nullptr), -1.0f);
3242 
3243 
3244     ArkUI_NumberValue chainModeVal[] = {{.i32 = ARKUI_AXIS_HORIZONTAL},
3245         {.i32 = ARKUI_RELATIVE_LAYOUT_CHAIN_STYLE_PACKED}};
3246     ArkUI_AttributeItem chainModeItem = {chainModeVal, sizeof(chainModeVal) / sizeof(ArkUI_NumberValue)};
3247     auto chainModRet = nodeAPI->setAttribute(rootNode, NODE_RELATIVE_LAYOUT_CHAIN_MODE, &chainModeItem);
3248     EXPECT_EQ(chainModRet, ARKUI_ERROR_CODE_NO_ERROR);
3249     EXPECT_EQ(nodeAPI->setAttribute(
3250         rootNode, NODE_RELATIVE_LAYOUT_CHAIN_MODE, nullptr), ARKUI_ERROR_CODE_PARAM_INVALID);
3251     auto chainModResult = nodeAPI->getAttribute(rootNode, NODE_RELATIVE_LAYOUT_CHAIN_MODE);
3252     EXPECT_NE(chainModResult, nullptr);
3253 
3254     int32_t guideLineOptSize = 1;
3255     float positionStart = 50.0f;
3256     float positionEnd = 60.0f;
3257     auto guidelineOption = OH_ArkUI_GuidelineOption_Create(guideLineOptSize);
3258     OH_ArkUI_GuidelineOption_SetId(nullptr, nullptr, 0);
3259     OH_ArkUI_GuidelineOption_SetId(guidelineOption, nullptr, -1);
3260     OH_ArkUI_GuidelineOption_SetId(guidelineOption, nullptr, 2);
3261     OH_ArkUI_GuidelineOption_SetId(guidelineOption, "__container__", 0);
3262     OH_ArkUI_GuidelineOption_SetDirection(nullptr, ARKUI_AXIS_VERTICAL, 0);
3263     OH_ArkUI_GuidelineOption_SetDirection(guidelineOption, ARKUI_AXIS_VERTICAL, -1);
3264     OH_ArkUI_GuidelineOption_SetDirection(guidelineOption, ARKUI_AXIS_VERTICAL, 2);
3265     OH_ArkUI_GuidelineOption_SetDirection(guidelineOption, ARKUI_AXIS_VERTICAL, 0);
3266     OH_ArkUI_GuidelineOption_SetPositionStart(nullptr, positionStart, 0);
3267     OH_ArkUI_GuidelineOption_SetPositionStart(guidelineOption, positionStart, -1);
3268     OH_ArkUI_GuidelineOption_SetPositionStart(guidelineOption, positionStart, 2);
3269     OH_ArkUI_GuidelineOption_SetPositionStart(guidelineOption, positionStart, 0);
3270     OH_ArkUI_GuidelineOption_SetPositionEnd(nullptr, positionEnd, 0);
3271     OH_ArkUI_GuidelineOption_SetPositionEnd(guidelineOption, positionEnd, -1);
3272     OH_ArkUI_GuidelineOption_SetPositionEnd(guidelineOption, positionEnd, 2);
3273     OH_ArkUI_GuidelineOption_SetPositionEnd(guidelineOption, positionEnd, 0);
3274     ArkUI_AttributeItem guidelineOptItem = {.object = guidelineOption};
3275     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_RELATIVE_CONTAINER_GUIDE_LINE, &guidelineOptItem),
3276         ARKUI_ERROR_CODE_NO_ERROR);
3277     auto guidelineOptResult = nodeAPI->getAttribute(rootNode, NODE_RELATIVE_CONTAINER_GUIDE_LINE);
3278     ASSERT_NE(guidelineOptResult, nullptr);
3279     OH_ArkUI_GuidelineOption_GetId(guidelineOption, 0);
3280     OH_ArkUI_GuidelineOption_GetDirection(guidelineOption, 0);
3281     OH_ArkUI_GuidelineOption_GetPositionStart(guidelineOption, 0);
3282     OH_ArkUI_GuidelineOption_GetPositionEnd(guidelineOption, 0);
3283     EXPECT_EQ(OH_ArkUI_GuidelineOption_GetId(nullptr, 0), nullptr);
3284     EXPECT_EQ(OH_ArkUI_GuidelineOption_GetId(guidelineOption, -1), nullptr);
3285     EXPECT_EQ(OH_ArkUI_GuidelineOption_GetId(guidelineOption, 2), nullptr);
3286     EXPECT_EQ(OH_ArkUI_GuidelineOption_GetDirection(nullptr, 0), static_cast<ArkUI_Axis>(-1));
3287     EXPECT_EQ(OH_ArkUI_GuidelineOption_GetDirection(guidelineOption, -1), static_cast<ArkUI_Axis>(-1));
3288     EXPECT_EQ(OH_ArkUI_GuidelineOption_GetDirection(guidelineOption, 2), static_cast<ArkUI_Axis>(-1));
3289     EXPECT_EQ(OH_ArkUI_GuidelineOption_GetPositionStart(nullptr, 0), 0.0f);
3290     EXPECT_EQ(OH_ArkUI_GuidelineOption_GetPositionStart(guidelineOption, -1), 0.0f);
3291     EXPECT_EQ(OH_ArkUI_GuidelineOption_GetPositionStart(guidelineOption, 2), 0.0f);
3292     EXPECT_EQ(OH_ArkUI_GuidelineOption_GetPositionEnd(nullptr, 0), 0.0f);
3293     EXPECT_EQ(OH_ArkUI_GuidelineOption_GetPositionEnd(guidelineOption, -1), 0.0f);
3294     EXPECT_EQ(OH_ArkUI_GuidelineOption_GetPositionEnd(guidelineOption, 2), 0.0f);
3295 
3296     auto abnormalBarrierOption = OH_ArkUI_BarrierOption_Create(-1);
3297     auto barrierOption = OH_ArkUI_BarrierOption_Create(guideLineOptSize);
3298     OH_ArkUI_BarrierOption_SetId(nullptr, nullptr, 0);
3299     OH_ArkUI_BarrierOption_SetId(barrierOption, nullptr, -1);
3300     OH_ArkUI_BarrierOption_SetId(barrierOption, nullptr, 2);
3301     OH_ArkUI_BarrierOption_SetId(barrierOption, "__container__", 0);
3302     OH_ArkUI_BarrierOption_SetDirection(nullptr, ARKUI_BARRIER_DIRECTION_TOP, 0);
3303     OH_ArkUI_BarrierOption_SetDirection(barrierOption, ARKUI_BARRIER_DIRECTION_TOP, -1);
3304     OH_ArkUI_BarrierOption_SetDirection(barrierOption, ARKUI_BARRIER_DIRECTION_TOP, 2);
3305     OH_ArkUI_BarrierOption_SetDirection(barrierOption, ARKUI_BARRIER_DIRECTION_TOP, 0);
3306     OH_ArkUI_BarrierOption_SetReferencedId(nullptr, nullptr, 0);
3307     OH_ArkUI_BarrierOption_SetReferencedId(barrierOption, nullptr, -1);
3308     OH_ArkUI_BarrierOption_SetReferencedId(barrierOption, nullptr, 2);
3309     OH_ArkUI_BarrierOption_SetReferencedId(barrierOption, "__container__", 0);
3310     ArkUI_AttributeItem barrierOptItem = {.object = barrierOption};
3311     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_RELATIVE_CONTAINER_BARRIER, &barrierOptItem),
3312         ARKUI_ERROR_CODE_NO_ERROR);
3313     auto barrierOptResult = nodeAPI->getAttribute(rootNode, NODE_RELATIVE_CONTAINER_BARRIER);
3314     ASSERT_NE(barrierOptResult, nullptr);
3315     OH_ArkUI_BarrierOption_GetId(barrierOption, 0);
3316     OH_ArkUI_BarrierOption_GetDirection(barrierOption, 0);
3317     OH_ArkUI_BarrierOption_GetReferencedId(barrierOption, 0, 0);
3318     OH_ArkUI_BarrierOption_GetReferencedIdSize(barrierOption, 0);
3319     EXPECT_EQ(OH_ArkUI_BarrierOption_GetId(nullptr, 0), nullptr);
3320     EXPECT_EQ(OH_ArkUI_BarrierOption_GetId(barrierOption, -1), nullptr);
3321     EXPECT_EQ(OH_ArkUI_BarrierOption_GetId(barrierOption, 2), nullptr);
3322     EXPECT_EQ(OH_ArkUI_BarrierOption_GetDirection(nullptr, 0), ARKUI_BARRIER_DIRECTION_TOP);
3323     EXPECT_EQ(OH_ArkUI_BarrierOption_GetDirection(barrierOption, -1), ARKUI_BARRIER_DIRECTION_TOP);
3324     EXPECT_EQ(OH_ArkUI_BarrierOption_GetDirection(barrierOption, 2), ARKUI_BARRIER_DIRECTION_TOP);
3325     EXPECT_EQ(OH_ArkUI_BarrierOption_GetReferencedId(nullptr, 0, 0), nullptr);
3326     EXPECT_EQ(OH_ArkUI_BarrierOption_GetReferencedId(barrierOption, -1, 0), nullptr);
3327     EXPECT_EQ(OH_ArkUI_BarrierOption_GetReferencedId(barrierOption, 2, 0), nullptr);
3328     EXPECT_EQ(OH_ArkUI_BarrierOption_GetReferencedId(barrierOption, 0, -1), nullptr);
3329     EXPECT_EQ(OH_ArkUI_BarrierOption_GetReferencedId(barrierOption, 0, 2), nullptr);
3330     EXPECT_EQ(OH_ArkUI_BarrierOption_GetReferencedIdSize(nullptr, 0), 0);
3331     EXPECT_EQ(OH_ArkUI_BarrierOption_GetReferencedIdSize(barrierOption, -1), 0);
3332     EXPECT_EQ(OH_ArkUI_BarrierOption_GetReferencedIdSize(barrierOption, 2), 0);
3333 
3334     OH_ArkUI_AlignmentRuleOption_Dispose(alignRules);
3335     OH_ArkUI_GuidelineOption_Dispose(guidelineOption);
3336     OH_ArkUI_BarrierOption_Dispose(barrierOption);
3337     OH_ArkUI_BarrierOption_Dispose(abnormalBarrierOption);
3338 
3339     OH_ArkUI_AlignmentRuleOption_Dispose(nullptr);
3340     OH_ArkUI_GuidelineOption_Dispose(nullptr);
3341     OH_ArkUI_BarrierOption_Dispose(nullptr);
3342 
3343     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_ALIGN_RULES), ARKUI_ERROR_CODE_NO_ERROR);
3344     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_RELATIVE_LAYOUT_CHAIN_MODE), ARKUI_ERROR_CODE_NO_ERROR);
3345     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_RELATIVE_CONTAINER_GUIDE_LINE), ARKUI_ERROR_CODE_NO_ERROR);
3346     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_RELATIVE_CONTAINER_BARRIER), ARKUI_ERROR_CODE_NO_ERROR);
3347     nodeAPI->disposeNode(rootNode);
3348 }
3349 
3350 /**
3351  * @tc.name: NativeNodeTest036
3352  * @tc.desc: Test imageAnimatorNode function.
3353  * @tc.type: FUNC
3354  */
HWTEST_F(NativeNodeTest, NativeNodeTest036, TestSize.Level1)3355 HWTEST_F(NativeNodeTest, NativeNodeTest036, TestSize.Level1)
3356 {
3357     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
3358         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
3359     auto rootNode = new ArkUI_Node({ARKUI_NODE_IMAGE_ANIMATOR, nullptr});
3360     ASSERT_NE(rootNode, nullptr);
3361     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_IMAGE_ANIMATOR_IMAGES), ARKUI_ERROR_CODE_NO_ERROR);
3362     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_IMAGE_ANIMATOR_STATE), ARKUI_ERROR_CODE_NO_ERROR);
3363     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_IMAGE_ANIMATOR_DURATION), ARKUI_ERROR_CODE_NO_ERROR);
3364     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_IMAGE_ANIMATOR_REVERSE), ARKUI_ERROR_CODE_NO_ERROR);
3365     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_IMAGE_ANIMATOR_FIXED_SIZE), ARKUI_ERROR_CODE_NO_ERROR);
3366     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_IMAGE_ANIMATOR_FILL_MODE), ARKUI_ERROR_CODE_NO_ERROR);
3367     EXPECT_EQ(nodeAPI->resetAttribute(rootNode, NODE_IMAGE_ANIMATOR_ITERATION), ARKUI_ERROR_CODE_NO_ERROR);
3368 
3369     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_IMAGE_ANIMATOR_IMAGES), nullptr);
3370     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_IMAGE_ANIMATOR_STATE), nullptr);
3371     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_IMAGE_ANIMATOR_DURATION), nullptr);
3372     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_IMAGE_ANIMATOR_REVERSE), nullptr);
3373     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_IMAGE_ANIMATOR_FIXED_SIZE), nullptr);
3374     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_IMAGE_ANIMATOR_FILL_MODE), nullptr);
3375     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_IMAGE_ANIMATOR_ITERATION), nullptr);
3376     nodeAPI->disposeNode(rootNode);
3377 }
3378 
3379 /**
3380  * @tc.name: NativeNodeTest037
3381  * @tc.desc: Test abnormalInputForCommon function.
3382  * @tc.type: FUNC
3383  */
HWTEST_F(NativeNodeTest, NativeNodeTest037, TestSize.Level1)3384 HWTEST_F(NativeNodeTest, NativeNodeTest037, TestSize.Level1)
3385 {
3386     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
3387         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
3388     auto rootNode = new ArkUI_Node({ARKUI_NODE_STACK, nullptr});
3389     float negativeFloat = -1.0f;
3390     int32_t negativeEnum = -1;
3391     uint32_t color = 0XFFFF0000;
3392     float val0 = 0.0f;
3393     float val1 = 1.0f;
3394     float val10 = 10.0f;
3395     ArkUI_NumberValue value[] = {{.f32 = negativeFloat}};
3396     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue)};
3397     ArkUI_NumberValue value4[] = {{.f32 = negativeFloat}, {.f32 = negativeFloat}, {.f32 = negativeFloat},
3398         {.f32 = negativeFloat}};
3399     ArkUI_AttributeItem item4 = {value4, sizeof(value4) / sizeof(ArkUI_NumberValue)};
3400     ArkUI_NumberValue value0[] = {};
3401     ArkUI_AttributeItem item0 = {value0, 0, nullptr, nullptr};
3402     ArkUI_NumberValue valueEnum[] = {{.i32 = negativeEnum}};
3403     ArkUI_AttributeItem itemEnum = {valueEnum, 1, "test", nullptr};
3404     ArkUI_NumberValue valueEnum4[] = {{.i32 = negativeEnum}, {.i32 = negativeEnum}, {.i32 = negativeEnum},
3405         {.i32 = negativeEnum}};
3406     ArkUI_AttributeItem itemEnum4 = {valueEnum4, sizeof(valueEnum4) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
3407 
3408     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_WIDTH, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
3409     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_WIDTH, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3410     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_HEIGHT, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
3411     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_HEIGHT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3412     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_WIDTH_PERCENT, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
3413     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_WIDTH_PERCENT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3414     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_HEIGHT_PERCENT, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
3415     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_HEIGHT_PERCENT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3416     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BACKGROUND_COLOR, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3417     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BACKGROUND_IMAGE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3418     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BACKGROUND_IMAGE, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3419     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_PADDING, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3420     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_PADDING_PERCENT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3421     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_ID, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3422     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_ENABLED, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3423     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_ENABLED, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3424     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_MARGIN, nullptr), ARKUI_ERROR_CODE_PARAM_INVALID);
3425     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_MARGIN, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3426     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_MARGIN_PERCENT, nullptr), ARKUI_ERROR_CODE_PARAM_INVALID);
3427     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_MARGIN_PERCENT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3428     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_FONT_COLOR, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
3429     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_FONT_SIZE, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
3430     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TRANSLATE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3431     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCALE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3432     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_ROTATE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3433     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BRIGHTNESS, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3434     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BRIGHTNESS, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
3435     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SATURATION, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3436     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SATURATION, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
3437     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BLUR, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3438     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LINEAR_GRADIENT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3439     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LINEAR_GRADIENT, &item4), ARKUI_ERROR_CODE_PARAM_INVALID);
3440     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_ALIGNMENT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3441     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_ALIGNMENT, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3442     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_OPACITY, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3443     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_OPACITY, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
3444     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BORDER_WIDTH, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3445     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BORDER_WIDTH, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
3446     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BORDER_WIDTH, &item4), ARKUI_ERROR_CODE_PARAM_INVALID);
3447     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BORDER_WIDTH_PERCENT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3448     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BORDER_WIDTH_PERCENT, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
3449     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BORDER_WIDTH_PERCENT, &item4), ARKUI_ERROR_CODE_PARAM_INVALID);
3450     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BORDER_RADIUS, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3451     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BORDER_RADIUS, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
3452     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BORDER_RADIUS, &item4), ARKUI_ERROR_CODE_PARAM_INVALID);
3453     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BORDER_RADIUS_PERCENT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3454     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BORDER_RADIUS_PERCENT, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
3455     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BORDER_RADIUS_PERCENT, &item4), ARKUI_ERROR_CODE_PARAM_INVALID);
3456     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BORDER_COLOR, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3457     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BORDER_STYLE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3458     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BORDER_STYLE, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3459     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BORDER_STYLE, &itemEnum4), ARKUI_ERROR_CODE_PARAM_INVALID);
3460     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_Z_INDEX, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3461     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_VISIBILITY, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3462     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_VISIBILITY, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3463     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CLIP, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3464     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CLIP, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3465     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CLIP_SHAPE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3466     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CLIP_SHAPE, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3467     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TRANSFORM, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3468     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_HIT_TEST_BEHAVIOR, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3469     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_HIT_TEST_BEHAVIOR, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3470     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_POSITION, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3471     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SHADOW, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3472     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SHADOW, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3473     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CUSTOM_SHADOW, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3474     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CUSTOM_SHADOW, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
3475     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_FOCUSABLE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3476     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_FOCUSABLE, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3477     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_ACCESSIBILITY_GROUP, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3478     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_ACCESSIBILITY_GROUP, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3479     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_ACCESSIBILITY_TEXT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3480     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_ACCESSIBILITY_MODE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3481     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_ACCESSIBILITY_MODE, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3482     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_ACCESSIBILITY_DESCRIPTION, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3483     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_ACCESSIBILITY_ACTIONS, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3484     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_ACCESSIBILITY_ROLE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3485     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_DEFAULT_FOCUS, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3486     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_DEFAULT_FOCUS, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3487     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_RESPONSE_REGION, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3488     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_OVERLAY, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3489     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_OVERLAY, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3490     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BACKGROUND_IMAGE_POSITION, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3491     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWEEP_GRADIENT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3492     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWEEP_GRADIENT, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3493     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_RADIAL_GRADIENT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3494     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_RADIAL_GRADIENT, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3495     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_MASK, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3496     ArkUI_NumberValue mask[] = {{.u32 = color}, {.u32 = color}, {.f32 = val10}, {.i32 = ARKUI_MASK_TYPE_RECTANGLE},
3497         {.f32 = negativeFloat}, {.f32 = negativeFloat}, {.f32 = negativeFloat}, {.f32 = negativeFloat}};
3498     ArkUI_AttributeItem maskItem = {mask, sizeof(mask) / sizeof(ArkUI_NumberValue)};
3499     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_MASK, &maskItem), ARKUI_ERROR_CODE_PARAM_INVALID);
3500     maskItem.size = 5;
3501     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_MASK, &maskItem), ARKUI_ERROR_CODE_PARAM_INVALID);
3502     mask[3].i32 = ARKUI_MASK_TYPE_PATH;
3503     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_MASK, &maskItem), ARKUI_ERROR_CODE_PARAM_INVALID);
3504     mask[0].i32 = ARKUI_MASK_TYPE_PROGRESS;
3505     mask[1].f32 = negativeFloat;
3506     mask[3].u32 = color;
3507     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_MASK, &maskItem), ARKUI_ERROR_CODE_PARAM_INVALID);
3508     mask[1].f32 = val10;
3509     mask[2].f32 = negativeFloat;
3510     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_MASK, &maskItem), ARKUI_ERROR_CODE_PARAM_INVALID);
3511     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BLEND_MODE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3512     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BLEND_MODE, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3513 
3514     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_DIRECTION, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3515     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_DIRECTION, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3516     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CONSTRAINT_SIZE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3517     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CONSTRAINT_SIZE, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3518     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CONSTRAINT_SIZE, &item4), ARKUI_ERROR_CODE_PARAM_INVALID);
3519     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_GRAY_SCALE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3520     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_GRAY_SCALE, &item4), ARKUI_ERROR_CODE_PARAM_INVALID);
3521     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_INVERT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3522     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_INVERT, &item4), ARKUI_ERROR_CODE_PARAM_INVALID);
3523     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SEPIA, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3524     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SEPIA, &item4), ARKUI_ERROR_CODE_PARAM_INVALID);
3525     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CONTRAST, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3526     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CONTRAST, &item4), ARKUI_ERROR_CODE_PARAM_INVALID);
3527     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_FOREGROUND_COLOR, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3528     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_OFFSET, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3529     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_MARK_ANCHOR, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3530     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_ALIGN_RULES, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3531     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_FOCUS_STATUS, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3532     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_FOCUS_STATUS, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3533     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_ASPECT_RATIO, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3534     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_ASPECT_RATIO, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
3535     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LAYOUT_WEIGHT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3536     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_DISPLAY_PRIORITY, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3537     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_OUTLINE_WIDTH, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3538     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_GEOMETRY_TRANSITION, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3539     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_RENDER_FIT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3540     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_RENDER_FIT, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3541     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_OUTLINE_COLOR, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3542     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SIZE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3543     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SIZE, &item4), ARKUI_ERROR_CODE_PARAM_INVALID);
3544     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_RENDER_GROUP, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3545     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_RENDER_GROUP, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3546     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_COLOR_BLEND, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3547     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BACKGROUND_IMAGE_SIZE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3548     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BACKGROUND_IMAGE_SIZE, &item4), ARKUI_ERROR_CODE_PARAM_INVALID);
3549     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BACKGROUND_IMAGE_SIZE_WITH_STYLE, &item0),
3550         ARKUI_ERROR_CODE_PARAM_INVALID);
3551     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BACKGROUND_IMAGE_SIZE_WITH_STYLE, &itemEnum),
3552         ARKUI_ERROR_CODE_PARAM_INVALID);
3553     ArkUI_NumberValue backgroundBlurVal[] = {{.i32 = ARKUI_BLUR_STYLE_THIN}, {.i32 = ARKUI_COLOR_MODE_SYSTEM},
3554         {.i32 = ARKUI_ADAPTIVE_COLOR_DEFAULT}, {.f32 = 0}, {.f32 = 0}, {.f32 = negativeFloat}};
3555     ArkUI_AttributeItem backgroundBlurItem = {backgroundBlurVal, sizeof(backgroundBlurVal) / sizeof(ArkUI_NumberValue)};
3556     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BACKGROUND_BLUR_STYLE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3557     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_FOREGROUND_BLUR_STYLE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3558     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BACKGROUND_BLUR_STYLE, &backgroundBlurItem),
3559         ARKUI_ERROR_CODE_PARAM_INVALID);
3560     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_FOREGROUND_BLUR_STYLE, &backgroundBlurItem),
3561         ARKUI_ERROR_CODE_PARAM_INVALID);
3562     backgroundBlurVal[4].f32 = negativeFloat;
3563     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BACKGROUND_BLUR_STYLE, &backgroundBlurItem),
3564         ARKUI_ERROR_CODE_PARAM_INVALID);
3565     backgroundBlurVal[3].f32 = negativeFloat;
3566     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BACKGROUND_BLUR_STYLE, &backgroundBlurItem),
3567         ARKUI_ERROR_CODE_PARAM_INVALID);
3568     backgroundBlurVal[2].i32 = negativeEnum;
3569     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BACKGROUND_BLUR_STYLE, &backgroundBlurItem),
3570         ARKUI_ERROR_CODE_PARAM_INVALID);
3571     backgroundBlurVal[1].i32 = negativeEnum;
3572     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BACKGROUND_BLUR_STYLE, &backgroundBlurItem),
3573         ARKUI_ERROR_CODE_PARAM_INVALID);
3574     backgroundBlurVal[0].i32 = negativeEnum;
3575     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BACKGROUND_BLUR_STYLE, &backgroundBlurItem),
3576         ARKUI_ERROR_CODE_PARAM_INVALID);
3577     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TRANSFORM_CENTER, &item4), ARKUI_ERROR_CODE_PARAM_INVALID);
3578     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_OPACITY_TRANSITION, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3579     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_ROTATE_TRANSITION, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3580     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCALE_TRANSITION, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3581     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TRANSLATE_TRANSITION, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3582     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_MOVE_TRANSITION, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3583     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LAYOUT_RECT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3584     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LAYOUT_RECT, &itemEnum4), ARKUI_ERROR_CODE_PARAM_INVALID);
3585     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_FOCUS_ON_TOUCH, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3586     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_FOCUS_ON_TOUCH, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3587     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_ACCESSIBILITY_STATE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3588     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_ACCESSIBILITY_VALUE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3589     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_EXPAND_SAFE_AREA, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3590     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_VISIBLE_AREA_CHANGE_RATIO, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3591     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_VISIBLE_AREA_CHANGE_RATIO, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
3592     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TRANSITION, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3593 
3594     ArkUI_NumberValue opacityTransition[] = {{.f32 = val0}, {.i32 = 1000}, {.i32 = ARKUI_CURVE_LINEAR}, {.i32 = 1000},
3595         {.i32 = 1}, {.i32 = ARKUI_ANIMATION_PLAY_MODE_NORMAL}, {.f32 = val1}};
3596     ArkUI_AttributeItem opacityTransitionItem =
3597         {opacityTransition, sizeof(opacityTransition) / sizeof(ArkUI_NumberValue)};
3598     opacityTransition[6].f32 = negativeFloat;
3599     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_OPACITY_TRANSITION, &opacityTransitionItem),
3600         ARKUI_ERROR_CODE_PARAM_INVALID);
3601     opacityTransition[5].i32 = negativeEnum;
3602     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_OPACITY_TRANSITION, &opacityTransitionItem),
3603         ARKUI_ERROR_CODE_PARAM_INVALID);
3604     opacityTransition[5].i32 = static_cast<int32_t>(ARKUI_ANIMATION_PLAY_MODE_ALTERNATE_REVERSE) + 1;
3605     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_OPACITY_TRANSITION, &opacityTransitionItem),
3606         ARKUI_ERROR_CODE_PARAM_INVALID);
3607     opacityTransition[2].i32 = negativeEnum;
3608     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_OPACITY_TRANSITION, &opacityTransitionItem),
3609         ARKUI_ERROR_CODE_PARAM_INVALID);
3610     opacityTransition[2].i32 = static_cast<int32_t>(ARKUI_CURVE_FRICTION) + 1;
3611     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_OPACITY_TRANSITION, &opacityTransitionItem),
3612         ARKUI_ERROR_CODE_PARAM_INVALID);
3613 
3614     valueEnum4[0].i32 = 0;
3615     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BLEND_MODE, &itemEnum4), ARKUI_ERROR_CODE_PARAM_INVALID);
3616     valueEnum4[2].i32 = 0;
3617     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LAYOUT_RECT, &itemEnum4), ARKUI_ERROR_CODE_PARAM_INVALID);
3618     valueEnum4[0].u32 = 0;
3619     valueEnum4[1].u32 = 0;
3620     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_EXPAND_SAFE_AREA, &itemEnum4), ARKUI_ERROR_CODE_NO_ERROR);
3621     valueEnum4[1].u32 = 20;
3622     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_EXPAND_SAFE_AREA, &itemEnum4), ARKUI_ERROR_CODE_PARAM_INVALID);
3623     valueEnum4[0].u32 = 20;
3624     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_EXPAND_SAFE_AREA, &itemEnum4), ARKUI_ERROR_CODE_PARAM_INVALID);
3625     valueEnum[0].u32 = -1;
3626     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_ACCESSIBILITY_ROLE, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3627     item0.size = -1;
3628     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TRANSFORM_CENTER, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3629     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BORDER_WIDTH, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3630     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BORDER_RADIUS, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3631     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BORDER_WIDTH_PERCENT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3632     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BORDER_RADIUS_PERCENT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3633     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BORDER_COLOR, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3634     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BORDER_STYLE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3635     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CUSTOM_SHADOW, &item0), ARKUI_ERROR_CODE_NO_ERROR);
3636     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_OUTLINE_COLOR, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3637     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_EXPAND_SAFE_AREA, &item0), ARKUI_ERROR_CODE_NO_ERROR);
3638     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_INPUT_PLACEHOLDER_FONT, &item0), ARKUI_ERROR_CODE_NO_ERROR);
3639     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_AREA_PLACEHOLDER_FONT, &item0), ARKUI_ERROR_CODE_NO_ERROR);
3640     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_AREA_SHOW_COUNTER, &item0), ARKUI_ERROR_CODE_NO_ERROR);
3641     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_ALIGN_RULES, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3642 
3643     value[0].f32 = 2.0f;
3644     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_OPACITY, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
3645     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_FONT_SIZE, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
3646     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_VISIBLE_AREA_CHANGE_RATIO, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
3647     valueEnum[0].i32 = static_cast<int32_t>(MAX_NODE_SCOPE_NUM);
3648     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BORDER_STYLE, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3649     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_VISIBILITY, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3650     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CLIP, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3651     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_HIT_TEST_BEHAVIOR, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3652     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SHADOW, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3653     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_DIRECTION, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3654     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_ALIGN_SELF, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3655     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_RENDER_FIT, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3656     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_FONT_WEIGHT, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3657     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_FONT_STYLE, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3658     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_INPUT_MAX_LENGTH, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3659     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_INPUT_ENTER_KEY_TYPE, &itemEnum),
3660         ARKUI_ERROR_CODE_PARAM_INVALID);
3661     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_INPUT_TYPE, &itemEnum),
3662         ARKUI_ERROR_CODE_PARAM_INVALID);
3663     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_AREA_TYPE, &itemEnum),
3664         ARKUI_ERROR_CODE_PARAM_INVALID);
3665     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_INPUT_ENABLE_KEYBOARD_ON_FOCUS, &itemEnum),
3666         ARKUI_ERROR_CODE_PARAM_INVALID);
3667     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_INPUT_SHOW_PASSWORD_ICON, &itemEnum),
3668         ARKUI_ERROR_CODE_PARAM_INVALID);
3669     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_INPUT_EDITING, &itemEnum),
3670         ARKUI_ERROR_CODE_PARAM_INVALID);
3671     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_AREA_EDITING, &itemEnum),
3672         ARKUI_ERROR_CODE_PARAM_INVALID);
3673     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_INPUT_CANCEL_BUTTON, &itemEnum),
3674         ARKUI_ERROR_CODE_PARAM_INVALID);
3675     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_STACK_ALIGN_CONTENT, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3676     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_CURVE, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3677     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_EDGE_EFFECT_MODE, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3678     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_DECORATION, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3679     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_CASE, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3680     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_ALIGN, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3681     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_OVERFLOW, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3682     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_SPAN_VERTICAL_ALIGNMENT, &itemEnum),
3683         ARKUI_ERROR_CODE_PARAM_INVALID);
3684     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_OBJECT_FIT, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3685     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_INTERPOLATION, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3686     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_OBJECT_REPEAT, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3687     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_RENDER_MODE, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3688     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_FIT_ORIGINAL_SIZE, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3689     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CALENDAR_PICKER_EDGE_ALIGNMENT, &itemEnum),
3690         ARKUI_ERROR_CODE_PARAM_INVALID);
3691     valueEnum4[0].i32 = static_cast<int32_t>(MAX_NODE_SCOPE_NUM);
3692     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BORDER_STYLE, &itemEnum4), ARKUI_ERROR_CODE_PARAM_INVALID);
3693     valueEnum[0].u32 = static_cast<int32_t>(MAX_NODE_SCOPE_NUM);
3694     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_ACCESSIBILITY_ACTIONS, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3695     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_INPUT_CARET_COLOR, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3696     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_INPUT_PLACEHOLDER_COLOR, &itemEnum),
3697         ARKUI_ERROR_CODE_PARAM_INVALID);
3698     valueEnum[0].i32 = true;
3699     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_FOCUS_STATUS, &itemEnum), ARKUI_ERROR_CODE_NO_ERROR);
3700     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_FONT_STYLE, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3701     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_COPY_OPTION, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3702 
3703     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_FOCUS_STATUS), nullptr);
3704     EXPECT_NE(nodeAPI->getAttribute(rootNode, NODE_OUTLINE_WIDTH), nullptr);
3705     nodeAPI->disposeNode(rootNode);
3706 }
3707 
3708 /**
3709  * @tc.name: NativeNodeTest038
3710  * @tc.desc: Test abnormalInputForText function.
3711  * @tc.type: FUNC
3712  */
HWTEST_F(NativeNodeTest, NativeNodeTest038, TestSize.Level1)3713 HWTEST_F(NativeNodeTest, NativeNodeTest038, TestSize.Level1)
3714 {
3715     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
3716         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
3717     auto rootNode = new ArkUI_Node({ARKUI_NODE_TEXT, nullptr});
3718     float negativeFloat = -1.0f;
3719     int32_t negativeInt = -1;
3720     ArkUI_NumberValue value[] = {{.f32 = negativeFloat}};
3721     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
3722     ArkUI_NumberValue value0[] = {};
3723     ArkUI_AttributeItem item0 = {value0, 0, nullptr, nullptr};
3724     ArkUI_NumberValue value4[] = {{.f32 = negativeFloat}, {.f32 = negativeFloat}, {.f32 = negativeFloat},
3725         {.f32 = negativeFloat}};
3726     ArkUI_AttributeItem item4 = {value4, sizeof(value4) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
3727     ArkUI_NumberValue valueEnum[] = {{.i32 = negativeInt}};
3728     ArkUI_AttributeItem itemEnum = {valueEnum, sizeof(valueEnum) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
3729     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_CONTENT, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
3730     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_FONT_COLOR, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3731     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_FONT_SIZE, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
3732     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_FONT_STYLE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3733     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_FONT_WEIGHT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3734     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_FONT_WEIGHT, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3735     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_LINE_HEIGHT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3736     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_DECORATION, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3737     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_DECORATION, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3738     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_CASE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3739     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_CASE, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3740     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_LETTER_SPACING, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3741     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_MAX_LINES, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3742     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_ALIGN, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3743     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_ALIGN, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3744     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_OVERFLOW, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3745     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_OVERFLOW, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3746     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_FONT_FAMILY, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3747     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_COPY_OPTION, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3748     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_BASELINE_OFFSET, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3749     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_TEXT_SHADOW, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3750     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_MIN_FONT_SIZE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3751     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_MAX_FONT_SIZE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3752     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_FONT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3753     value4[1].i32 = negativeInt;
3754     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_FONT, &item4), ARKUI_ERROR_CODE_PARAM_INVALID);
3755     value4[1].i32 = 0;
3756     value4[2].i32 = negativeInt;
3757     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_FONT, &item4), ARKUI_ERROR_CODE_PARAM_INVALID);
3758     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_HEIGHT_ADAPTIVE_POLICY, &item0),
3759         ARKUI_ERROR_CODE_PARAM_INVALID);
3760     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_HEIGHT_ADAPTIVE_POLICY, &itemEnum),
3761         ARKUI_ERROR_CODE_PARAM_INVALID);
3762     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_INDENT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3763     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_WORD_BREAK, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3764     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_ELLIPSIS_MODE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3765     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_LINE_SPACING, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3766     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_LINE_SPACING, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
3767     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_FONT_FEATURE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3768     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_ENABLE_DATA_DETECTOR, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3769     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_SELECTED_BACKGROUND_COLOR, &item0),
3770         ARKUI_ERROR_CODE_PARAM_INVALID);
3771     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_CONTENT_WITH_STYLED_STRING, &item0),
3772         ARKUI_ERROR_CODE_PARAM_INVALID);
3773     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_CONTENT_WITH_STYLED_STRING, nullptr),
3774         ARKUI_ERROR_CODE_PARAM_INVALID);
3775     nodeAPI->disposeNode(rootNode);
3776 }
3777 
3778 /**
3779  * @tc.name: NativeNodeTest039
3780  * @tc.desc: Test abnormalInputForTextField function.
3781  * @tc.type: FUNC
3782  */
HWTEST_F(NativeNodeTest, NativeNodeTest039, TestSize.Level1)3783 HWTEST_F(NativeNodeTest, NativeNodeTest039, TestSize.Level1)
3784 {
3785     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
3786         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
3787     auto textinput = new ArkUI_Node({ARKUI_NODE_TEXT_INPUT, nullptr});
3788     auto textarea = new ArkUI_Node({ARKUI_NODE_TEXT_AREA, nullptr});
3789     float negativeFloat = -1.0f;
3790     int32_t negativeInt = -1;
3791     ArkUI_NumberValue value[] = {{.f32 = negativeFloat}};
3792     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue)};
3793     ArkUI_NumberValue value0[] = {};
3794     ArkUI_AttributeItem item0 = {value0, 0, nullptr, nullptr};
3795     ArkUI_NumberValue value4[] = {{.f32 = 0.0f}, {.i32 = negativeInt}, {.i32 = negativeInt},
3796         {.i32 = negativeInt}};
3797     ArkUI_AttributeItem item4 = {value4, sizeof(value4) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
3798     ArkUI_NumberValue valueEnum[] = {{.i32 = negativeInt}};
3799     ArkUI_AttributeItem itemEnum = {valueEnum, sizeof(valueEnum) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
3800 
3801     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_CARET_COLOR, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3802     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_CARET_STYLE, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
3803     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_SHOW_UNDERLINE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3804     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_SHOW_UNDERLINE, &itemEnum),
3805         ARKUI_ERROR_CODE_PARAM_INVALID);
3806     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_MAX_LENGTH, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3807     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_MAX_LENGTH, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3808     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_ENTER_KEY_TYPE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3809     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_ENTER_KEY_TYPE, &itemEnum),
3810         ARKUI_ERROR_CODE_PARAM_INVALID);
3811     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_PLACEHOLDER_COLOR, &item0),
3812         ARKUI_ERROR_CODE_PARAM_INVALID);
3813     EXPECT_EQ(nodeAPI->setAttribute(
3814         textinput, NODE_TEXT_INPUT_PLACEHOLDER_FONT, nullptr), ARKUI_ERROR_CODE_PARAM_INVALID);
3815     EXPECT_EQ(nodeAPI->setAttribute(
3816         textinput, NODE_TEXT_INPUT_PLACEHOLDER_FONT, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
3817     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_ENABLE_KEYBOARD_ON_FOCUS, &item0),
3818         ARKUI_ERROR_CODE_PARAM_INVALID);
3819     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_ENABLE_KEYBOARD_ON_FOCUS, &itemEnum),
3820         ARKUI_ERROR_CODE_PARAM_INVALID);
3821     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_TYPE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3822     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_TYPE, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3823     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_SELECTED_BACKGROUND_COLOR, &item0),
3824         ARKUI_ERROR_CODE_PARAM_INVALID);
3825     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_SHOW_PASSWORD_ICON, &item0),
3826         ARKUI_ERROR_CODE_PARAM_INVALID);
3827     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_SHOW_PASSWORD_ICON, &itemEnum),
3828         ARKUI_ERROR_CODE_PARAM_INVALID);
3829     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_EDITING, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3830     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_EDITING, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3831     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_CANCEL_BUTTON, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3832     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_CANCEL_BUTTON, &itemEnum),
3833         ARKUI_ERROR_CODE_PARAM_INVALID);
3834     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_TEXT_SELECTION, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3835     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_UNDERLINE_COLOR, &item0),
3836         ARKUI_ERROR_CODE_PARAM_INVALID);
3837     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_ENABLE_AUTO_FILL, &item0),
3838         ARKUI_ERROR_CODE_PARAM_INVALID);
3839     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_CONTENT_TYPE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3840     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_SELECT_ALL, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3841     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_STYLE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3842     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_CARET_OFFSET, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3843     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_SELECTION_MENU_HIDDEN, &item0),
3844         ARKUI_ERROR_CODE_PARAM_INVALID);
3845     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_SELECTION_MENU_HIDDEN, &itemEnum),
3846         ARKUI_ERROR_CODE_PARAM_INVALID);
3847     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_BLUR_ON_SUBMIT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3848     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_CUSTOM_KEYBOARD, &item0),
3849         ARKUI_ERROR_CODE_PARAM_INVALID);
3850     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_WORD_BREAK, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3851     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_SHOW_KEYBOARD_ON_FOCUS, &item0),
3852         ARKUI_ERROR_CODE_PARAM_INVALID);
3853     EXPECT_EQ(nodeAPI->setAttribute(textinput, NODE_TEXT_INPUT_NUMBER_OF_LINES, &item0),
3854         ARKUI_ERROR_CODE_PARAM_INVALID);
3855 
3856     EXPECT_EQ(nodeAPI->setAttribute(
3857         textarea, NODE_TEXT_AREA_PLACEHOLDER_FONT, nullptr), ARKUI_ERROR_CODE_PARAM_INVALID);
3858     EXPECT_EQ(nodeAPI->setAttribute(
3859         textarea, NODE_TEXT_AREA_PLACEHOLDER_FONT, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
3860     EXPECT_EQ(nodeAPI->setAttribute(
3861         textarea, NODE_TEXT_AREA_PLACEHOLDER_FONT, &item4), ARKUI_ERROR_CODE_PARAM_INVALID);
3862     value4[1].i32 = ARKUI_FONT_STYLE_ITALIC;
3863     EXPECT_EQ(nodeAPI->setAttribute(
3864         textarea, NODE_TEXT_AREA_PLACEHOLDER_FONT, &item4), ARKUI_ERROR_CODE_PARAM_INVALID);
3865     EXPECT_EQ(nodeAPI->setAttribute(
3866         textinput, NODE_TEXT_INPUT_PLACEHOLDER_FONT, &item4), ARKUI_ERROR_CODE_PARAM_INVALID);
3867     EXPECT_EQ(nodeAPI->setAttribute(textarea, NODE_TEXT_AREA_EDITING, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3868     EXPECT_EQ(nodeAPI->setAttribute(textarea, NODE_TEXT_AREA_TYPE, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3869     EXPECT_EQ(nodeAPI->setAttribute(textarea, NODE_TEXT_AREA_SHOW_COUNTER, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3870     value4[0].i32 = negativeInt;
3871     EXPECT_EQ(nodeAPI->setAttribute(textarea, NODE_TEXT_AREA_SHOW_COUNTER, &item4), ARKUI_ERROR_CODE_PARAM_INVALID);
3872     value4[0].i32 = 0;
3873     value4[1].f32 = negativeFloat;
3874     EXPECT_EQ(nodeAPI->setAttribute(textarea, NODE_TEXT_AREA_SHOW_COUNTER, &item4), ARKUI_ERROR_CODE_PARAM_INVALID);
3875     value4[1].f32 = 1.0f;
3876     value4[2].i32 = negativeInt;
3877     EXPECT_EQ(nodeAPI->setAttribute(textarea, NODE_TEXT_AREA_SHOW_COUNTER, &item4), ARKUI_ERROR_CODE_PARAM_INVALID);
3878     EXPECT_EQ(nodeAPI->setAttribute(
3879         textarea, NODE_TEXT_AREA_SELECTION_MENU_HIDDEN, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3880     EXPECT_EQ(nodeAPI->setAttribute(
3881         textarea, NODE_TEXT_AREA_SELECTION_MENU_HIDDEN, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3882     nodeAPI->disposeNode(textinput);
3883     nodeAPI->disposeNode(textarea);
3884 }
3885 
3886 /**
3887  * @tc.name: NativeNodeTest040
3888  * @tc.desc: Test abnormalInputForWaterflow function.
3889  * @tc.type: FUNC
3890  */
HWTEST_F(NativeNodeTest, NativeNodeTest040, TestSize.Level1)3891 HWTEST_F(NativeNodeTest, NativeNodeTest040, TestSize.Level1)
3892 {
3893     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
3894         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
3895     auto rootNode = nodeAPI->createNode(ARKUI_NODE_WATER_FLOW);
3896     float negativeFloat = -1.0f;
3897     ArkUI_NumberValue value[] = {{.f32 = negativeFloat}};
3898     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue)};
3899     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_COLUMN_GAP, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
3900     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_ROW_GAP, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
3901     nodeAPI->disposeNode(rootNode);
3902 }
3903 
3904 /**
3905  * @tc.name: NativeNodeTest041
3906  * @tc.desc: Test abnormalInputForGrid function.
3907  * @tc.type: FUNC
3908  */
HWTEST_F(NativeNodeTest, NativeNodeTest041, TestSize.Level1)3909 HWTEST_F(NativeNodeTest, NativeNodeTest041, TestSize.Level1)
3910 {
3911     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
3912         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
3913     auto rootNode = nodeAPI->createNode(ARKUI_NODE_GRID);
3914     float negativeFloat = -1.0f;
3915     ArkUI_NumberValue value[] = {{.f32 = negativeFloat}};
3916     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue)};
3917     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_GRID_COLUMN_GAP, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
3918     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_GRID_ROW_GAP, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
3919     nodeAPI->disposeNode(rootNode);
3920 }
3921 
3922 /**
3923  * @tc.name: NativeNodeTest042
3924  * @tc.desc: Test abnormalInputForSpan function.
3925  * @tc.type: FUNC
3926  */
HWTEST_F(NativeNodeTest, NativeNodeTest042, TestSize.Level1)3927 HWTEST_F(NativeNodeTest, NativeNodeTest042, TestSize.Level1)
3928 {
3929     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
3930         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
3931     auto rootNode = nodeAPI->createNode(ARKUI_NODE_SPAN);
3932     float negativeFloat = -1.0f;
3933     ArkUI_NumberValue value[] = {{.f32 = negativeFloat}};
3934     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
3935     ArkUI_NumberValue value0[] = {};
3936     ArkUI_AttributeItem item0 = {value0, 0, nullptr, nullptr};
3937     ArkUI_NumberValue value4[] = {{.f32 = negativeFloat}, {.f32 = negativeFloat}, {.f32 = negativeFloat},
3938         {.f32 = negativeFloat}};
3939     ArkUI_AttributeItem item4 = {value4, sizeof(value4) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
3940     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SPAN_CONTENT, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
3941     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SPAN_TEXT_BACKGROUND_STYLE, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
3942     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SPAN_TEXT_BACKGROUND_STYLE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3943     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SPAN_TEXT_BACKGROUND_STYLE, &item4), ARKUI_ERROR_CODE_PARAM_INVALID);
3944     nodeAPI->disposeNode(rootNode);
3945 }
3946 
3947 /**
3948  * @tc.name: NativeNodeTest043
3949  * @tc.desc: Test abnormalInputForImageSpan function.
3950  * @tc.type: FUNC
3951  */
HWTEST_F(NativeNodeTest, NativeNodeTest043, TestSize.Level1)3952 HWTEST_F(NativeNodeTest, NativeNodeTest043, TestSize.Level1)
3953 {
3954     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
3955         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
3956     auto rootNode = new ArkUI_Node({ARKUI_NODE_IMAGE_SPAN, nullptr});
3957     int32_t negativeInt = -1;
3958     ArkUI_NumberValue value0[] = {};
3959     ArkUI_AttributeItem item0 = {value0, 0, nullptr, nullptr};
3960     ArkUI_NumberValue valueEnum[] = {{.i32 = negativeInt}};
3961     ArkUI_AttributeItem itemEnum = {valueEnum, sizeof(valueEnum) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
3962     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_SPAN_SRC, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3963     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_SPAN_VERTICAL_ALIGNMENT, &item0),
3964         ARKUI_ERROR_CODE_PARAM_INVALID);
3965     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_SPAN_VERTICAL_ALIGNMENT, &itemEnum),
3966         ARKUI_ERROR_CODE_PARAM_INVALID);
3967     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_SPAN_ALT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3968     nodeAPI->disposeNode(rootNode);
3969 }
3970 
3971 /**
3972  * @tc.name: NativeNodeTest044
3973  * @tc.desc: Test abnormalInputForImage function.
3974  * @tc.type: FUNC
3975  */
HWTEST_F(NativeNodeTest, NativeNodeTest044, TestSize.Level1)3976 HWTEST_F(NativeNodeTest, NativeNodeTest044, TestSize.Level1)
3977 {
3978     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
3979         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
3980     auto rootNode = new ArkUI_Node({ARKUI_NODE_IMAGE, nullptr});
3981     int32_t negativeInt = -1;
3982     ArkUI_NumberValue value0[] = {};
3983     ArkUI_AttributeItem item0 = {value0, 0, nullptr, nullptr};
3984     ArkUI_NumberValue valueEnum[] = {{.i32 = negativeInt}};
3985     ArkUI_AttributeItem itemEnum = {valueEnum, sizeof(valueEnum) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
3986     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_SRC, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3987     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_OBJECT_FIT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3988     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_OBJECT_FIT, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3989     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_INTERPOLATION, &itemEnum),
3990         ARKUI_ERROR_CODE_PARAM_INVALID);
3991     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_INTERPOLATION, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3992     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_OBJECT_REPEAT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3993     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_OBJECT_REPEAT, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
3994     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_COLOR_FILTER, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3995     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_AUTO_RESIZE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3996     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_ALT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3997     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_DRAGGABLE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3998     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_RENDER_MODE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
3999     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_RENDER_MODE, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4000     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_FIT_ORIGINAL_SIZE, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4001     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_FIT_ORIGINAL_SIZE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4002     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_FILL_COLOR, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4003     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_RESIZABLE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4004     nodeAPI->disposeNode(rootNode);
4005 }
4006 
4007 /**
4008  * @tc.name: NativeNodeTest045
4009  * @tc.desc: Test abnormalInputForToggle function.
4010  * @tc.type: FUNC
4011  */
HWTEST_F(NativeNodeTest, NativeNodeTest045, TestSize.Level1)4012 HWTEST_F(NativeNodeTest, NativeNodeTest045, TestSize.Level1)
4013 {
4014     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
4015         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
4016     auto rootNode = nodeAPI->createNode(ARKUI_NODE_TOGGLE);
4017     ArkUI_NumberValue value0[] = {};
4018     ArkUI_AttributeItem item0 = {value0, 0, nullptr, nullptr};
4019     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TOGGLE_SELECTED_COLOR, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4020     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TOGGLE_SWITCH_POINT_COLOR, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4021     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TOGGLE_VALUE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4022     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TOGGLE_UNSELECTED_COLOR, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4023     nodeAPI->disposeNode(rootNode);
4024 }
4025 
4026 /**
4027  * @tc.name: NativeNodeTest046
4028  * @tc.desc: Test abnormalInputForLoadingProgress function.
4029  * @tc.type: FUNC
4030  */
HWTEST_F(NativeNodeTest, NativeNodeTest046, TestSize.Level1)4031 HWTEST_F(NativeNodeTest, NativeNodeTest046, TestSize.Level1)
4032 {
4033     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
4034         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
4035     auto rootNode = nodeAPI->createNode(ARKUI_NODE_LOADING_PROGRESS);
4036     ArkUI_NumberValue value0[] = {};
4037     ArkUI_AttributeItem item0 = {value0, 0, nullptr, nullptr};
4038     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LOADING_PROGRESS_COLOR, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4039     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LOADING_PROGRESS_ENABLE_LOADING, &item0),
4040         ARKUI_ERROR_CODE_PARAM_INVALID);
4041     nodeAPI->disposeNode(rootNode);
4042 }
4043 
4044 /**
4045  * @tc.name: NativeNodeTest047
4046  * @tc.desc: Test abnormalInputForButton function.
4047  * @tc.type: FUNC
4048  */
HWTEST_F(NativeNodeTest, NativeNodeTest047, TestSize.Level1)4049 HWTEST_F(NativeNodeTest, NativeNodeTest047, TestSize.Level1)
4050 {
4051     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
4052         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
4053     auto rootNode = new ArkUI_Node({ARKUI_NODE_BUTTON, nullptr});
4054     int32_t negativeInt = -1;
4055     ArkUI_NumberValue value0[] = {};
4056     ArkUI_AttributeItem item0 = {value0, 0, nullptr, nullptr};
4057     ArkUI_NumberValue valueEnum[] = {{.i32 = negativeInt}};
4058     ArkUI_AttributeItem itemEnum = {valueEnum, sizeof(valueEnum) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
4059     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BUTTON_LABEL, nullptr), ARKUI_ERROR_CODE_PARAM_INVALID);
4060     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BUTTON_LABEL, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4061     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BUTTON_TYPE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4062     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_BUTTON_TYPE, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4063     nodeAPI->disposeNode(rootNode);
4064 }
4065 
4066 /**
4067  * @tc.name: NativeNodeTest048
4068  * @tc.desc: Test abnormalInputForProgress function.
4069  * @tc.type: FUNC
4070  */
HWTEST_F(NativeNodeTest, NativeNodeTest048, TestSize.Level1)4071 HWTEST_F(NativeNodeTest, NativeNodeTest048, TestSize.Level1)
4072 {
4073     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
4074         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
4075     auto rootNode = nodeAPI->createNode(ARKUI_NODE_PROGRESS);
4076     ArkUI_NumberValue value0[] = {};
4077     ArkUI_AttributeItem item0 = {value0, 0, nullptr, nullptr};
4078     ArkUI_NumberValue value[] = {{.f32 = -1.0f}};
4079     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
4080     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_PROGRESS_VALUE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4081     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_PROGRESS_VALUE, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4082     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_PROGRESS_TOTAL, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4083     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_PROGRESS_TOTAL, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4084     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_PROGRESS_COLOR, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4085     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_PROGRESS_TYPE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4086     value[0].i32 = -1;
4087     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_PROGRESS_TYPE, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4088     nodeAPI->disposeNode(rootNode);
4089 }
4090 
4091 /**
4092  * @tc.name: NativeNodeTest049
4093  * @tc.desc: Test abnormalInputForCheckbox function.
4094  * @tc.type: FUNC
4095  */
HWTEST_F(NativeNodeTest, NativeNodeTest049, TestSize.Level1)4096 HWTEST_F(NativeNodeTest, NativeNodeTest049, TestSize.Level1)
4097 {
4098     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
4099         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
4100     auto rootNode = nodeAPI->createNode(ARKUI_NODE_CHECKBOX);
4101     uint32_t color = 0xFFFF0000;
4102     float negativeFloat = -1.0f;
4103     ArkUI_NumberValue value0[] = {};
4104     ArkUI_AttributeItem item0 = {value0, 0, nullptr, nullptr};
4105     ArkUI_NumberValue value[] = {{.i32 = -1}};
4106     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
4107     ArkUI_NumberValue mark[] = {{.u32 = color}, {.f32 = negativeFloat}, {.f32 = negativeFloat}};
4108     ArkUI_AttributeItem markItem = {mark, sizeof(mark) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
4109     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CHECKBOX_SELECT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4110     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CHECKBOX_SELECT, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4111     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CHECKBOX_SELECT_COLOR, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4112     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CHECKBOX_UNSELECT_COLOR, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4113     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CHECKBOX_MARK, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4114     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CHECKBOX_MARK, &markItem), ARKUI_ERROR_CODE_PARAM_INVALID);
4115     mark[1].f32 = 0.0f;
4116     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CHECKBOX_MARK, &markItem), ARKUI_ERROR_CODE_PARAM_INVALID);
4117     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CHECKBOX_SHAPE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4118     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CHECKBOX_SHAPE, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4119     nodeAPI->disposeNode(rootNode);
4120 }
4121 
4122 /**
4123  * @tc.name: NativeNodeTest050
4124  * @tc.desc: Test abnormalInputForXComponent function.
4125  * @tc.type: FUNC
4126  */
HWTEST_F(NativeNodeTest, NativeNodeTest050, TestSize.Level1)4127 HWTEST_F(NativeNodeTest, NativeNodeTest050, TestSize.Level1)
4128 {
4129     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
4130         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
4131     auto rootNode = nodeAPI->createNode(ARKUI_NODE_XCOMPONENT);
4132     ArkUI_NumberValue value0[] = {};
4133     ArkUI_AttributeItem item0 = {value0, 0, nullptr, nullptr};
4134     ArkUI_NumberValue value[] = {{.i32 = -1}};
4135     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
4136     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_XCOMPONENT_ID, nullptr), ARKUI_ERROR_CODE_PARAM_INVALID);
4137     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_XCOMPONENT_ID, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4138     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_XCOMPONENT_TYPE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4139     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_XCOMPONENT_TYPE, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4140     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_XCOMPONENT_SURFACE_SIZE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4141     nodeAPI->disposeNode(rootNode);
4142 }
4143 
4144 /**
4145  * @tc.name: NativeNodeTest051
4146  * @tc.desc: Test abnormalInputForDatePicker function.
4147  * @tc.type: FUNC
4148  */
HWTEST_F(NativeNodeTest, NativeNodeTest051, TestSize.Level1)4149 HWTEST_F(NativeNodeTest, NativeNodeTest051, TestSize.Level1)
4150 {
4151     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
4152         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
4153     auto rootNode = nodeAPI->createNode(ARKUI_NODE_STACK);
4154     float negativeFloat = -1.0f;
4155     int32_t negativeInt = -1;
4156     ArkUI_NumberValue value0[] = {};
4157     ArkUI_AttributeItem item0 = {value0, 0, nullptr, nullptr};
4158     ArkUI_NumberValue value[] = {{.f32 = negativeFloat}};
4159     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue), "test", nullptr};
4160     ArkUI_NumberValue valueEnum[] = {{.i32 = negativeInt}};
4161     ArkUI_AttributeItem itemEnum = {valueEnum, sizeof(valueEnum) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
4162     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_DATE_PICKER_LUNAR, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4163     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_DATE_PICKER_LUNAR, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4164     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_DATE_PICKER_START, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4165     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_DATE_PICKER_START, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4166     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_DATE_PICKER_END, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4167     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_DATE_PICKER_END, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4168     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_DATE_PICKER_SELECTED, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4169     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_DATE_PICKER_SELECTED, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4170     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_DATE_PICKER_DISAPPEAR_TEXT_STYLE, &item),
4171         ARKUI_ERROR_CODE_PARAM_INVALID);
4172     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_DATE_PICKER_DISAPPEAR_TEXT_STYLE, &item0),
4173         ARKUI_ERROR_CODE_PARAM_INVALID);
4174     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_DATE_PICKER_TEXT_STYLE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4175     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_DATE_PICKER_TEXT_STYLE, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4176     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_DATE_PICKER_SELECTED_TEXT_STYLE, &item0),
4177         ARKUI_ERROR_CODE_PARAM_INVALID);
4178     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_DATE_PICKER_SELECTED_TEXT_STYLE, &item),
4179         ARKUI_ERROR_CODE_PARAM_INVALID);
4180     item.string = "test;10;normal;test;italic";
4181     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_DATE_PICKER_SELECTED_TEXT_STYLE, &item),
4182         ARKUI_ERROR_CODE_NO_ERROR);
4183     item.string = "#ff182431;test;normal;test;italic";
4184     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_DATE_PICKER_SELECTED_TEXT_STYLE, &item),
4185         ARKUI_ERROR_CODE_PARAM_INVALID);
4186     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_DATE_PICKER_TEXT_STYLE, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4187     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_DATE_PICKER_DISAPPEAR_TEXT_STYLE, &item),
4188         ARKUI_ERROR_CODE_PARAM_INVALID);
4189     nodeAPI->disposeNode(rootNode);
4190 }
4191 
4192 /**
4193  * @tc.name: NativeNodeTest052
4194  * @tc.desc: Test abnormalInputForTimePicker function.
4195  * @tc.type: FUNC
4196  */
HWTEST_F(NativeNodeTest, NativeNodeTest052, TestSize.Level1)4197 HWTEST_F(NativeNodeTest, NativeNodeTest052, TestSize.Level1)
4198 {
4199     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
4200         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
4201     auto rootNode = nodeAPI->createNode(ARKUI_NODE_STACK);
4202     float negativeFloat = -1.0f;
4203     ArkUI_NumberValue value0[] = {};
4204     ArkUI_AttributeItem item0 = {value0, 0, nullptr, nullptr};
4205     ArkUI_NumberValue value[] = {{.f32 = negativeFloat}};
4206     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue), "test", nullptr};
4207     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TIME_PICKER_SELECTED, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4208     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TIME_PICKER_SELECTED, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4209     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TIME_PICKER_USE_MILITARY_TIME, &item0),
4210         ARKUI_ERROR_CODE_PARAM_INVALID);
4211     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TIME_PICKER_DISAPPEAR_TEXT_STYLE, &item0),
4212         ARKUI_ERROR_CODE_PARAM_INVALID);
4213     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TIME_PICKER_DISAPPEAR_TEXT_STYLE, &item),
4214         ARKUI_ERROR_CODE_PARAM_INVALID);
4215     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TIME_PICKER_TEXT_STYLE, &item0),
4216         ARKUI_ERROR_CODE_PARAM_INVALID);
4217     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TIME_PICKER_TEXT_STYLE, &item),
4218         ARKUI_ERROR_CODE_PARAM_INVALID);
4219     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TIME_PICKER_SELECTED_TEXT_STYLE, &item0),
4220         ARKUI_ERROR_CODE_PARAM_INVALID);
4221     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TIME_PICKER_SELECTED_TEXT_STYLE, &item),
4222         ARKUI_ERROR_CODE_PARAM_INVALID);
4223     item.string = "#ff182431;test;normal;test;italic";
4224     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TIME_PICKER_SELECTED_TEXT_STYLE, &item),
4225         ARKUI_ERROR_CODE_PARAM_INVALID);
4226     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TIME_PICKER_TEXT_STYLE, &item),
4227         ARKUI_ERROR_CODE_PARAM_INVALID);
4228     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TIME_PICKER_DISAPPEAR_TEXT_STYLE, &item),
4229         ARKUI_ERROR_CODE_PARAM_INVALID);
4230     item.string = "50-60";
4231     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TIME_PICKER_SELECTED, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4232     item.string = "10-60";
4233     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TIME_PICKER_SELECTED, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4234     nodeAPI->disposeNode(rootNode);
4235 }
4236 
4237 /**
4238  * @tc.name: NativeNodeTest053
4239  * @tc.desc: Test abnormalInputForTextPicker function.
4240  * @tc.type: FUNC
4241  */
HWTEST_F(NativeNodeTest, NativeNodeTest053, TestSize.Level1)4242 HWTEST_F(NativeNodeTest, NativeNodeTest053, TestSize.Level1)
4243 {
4244     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
4245         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
4246     auto rootNode = nodeAPI->createNode(ARKUI_NODE_STACK);
4247     ArkUI_NumberValue value0[] = {};
4248     ArkUI_AttributeItem item0 = {value0, 0, nullptr, nullptr};
4249     ArkUI_NumberValue value[] = {{.i32 = ARKUI_TEXTPICKER_RANGETYPE_SINGLE}};
4250     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
4251     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_PICKER_OPTION_RANGE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4252     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_PICKER_OPTION_RANGE, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4253     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_PICKER_OPTION_SELECTED, &item0),
4254         ARKUI_ERROR_CODE_PARAM_INVALID);
4255     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_PICKER_OPTION_VALUE, &item0),
4256         ARKUI_ERROR_CODE_PARAM_INVALID);
4257     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_PICKER_DISAPPEAR_TEXT_STYLE, &item0),
4258         ARKUI_ERROR_CODE_PARAM_INVALID);
4259     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_PICKER_TEXT_STYLE, &item0),
4260         ARKUI_ERROR_CODE_PARAM_INVALID);
4261     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_PICKER_SELECTED_TEXT_STYLE, &item0),
4262         ARKUI_ERROR_CODE_PARAM_INVALID);
4263     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_PICKER_SELECTED_INDEX, &item0),
4264         ARKUI_ERROR_CODE_PARAM_INVALID);
4265     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_PICKER_CAN_LOOP, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4266     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_PICKER_DEFAULT_PICKER_ITEM_HEIGHT, &item0),
4267         ARKUI_ERROR_CODE_PARAM_INVALID);
4268     item.string = "test";
4269     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_PICKER_DISAPPEAR_TEXT_STYLE, &item),
4270         ARKUI_ERROR_CODE_PARAM_INVALID);
4271     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_PICKER_TEXT_STYLE, &item),
4272         ARKUI_ERROR_CODE_PARAM_INVALID);
4273     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_PICKER_SELECTED_TEXT_STYLE, &item),
4274         ARKUI_ERROR_CODE_PARAM_INVALID);
4275     item.string = "#ff182431;test;normal;test;italic";
4276     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_PICKER_DISAPPEAR_TEXT_STYLE, &item),
4277         ARKUI_ERROR_CODE_PARAM_INVALID);
4278     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_PICKER_TEXT_STYLE, &item),
4279         ARKUI_ERROR_CODE_PARAM_INVALID);
4280     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_TEXT_PICKER_SELECTED_TEXT_STYLE, &item),
4281         ARKUI_ERROR_CODE_PARAM_INVALID);
4282     nodeAPI->disposeNode(rootNode);
4283 }
4284 
4285 /**
4286  * @tc.name: NativeNodeTest054
4287  * @tc.desc: Test abnormalInputForCalendarPicker function.
4288  * @tc.type: FUNC
4289  */
HWTEST_F(NativeNodeTest, NativeNodeTest054, TestSize.Level1)4290 HWTEST_F(NativeNodeTest, NativeNodeTest054, TestSize.Level1)
4291 {
4292     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
4293         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
4294     auto rootNode = nodeAPI->createNode(ARKUI_NODE_CALENDAR_PICKER);
4295     float negativeFloat = -1.0f;
4296     int32_t negativeInt = -1;
4297     ArkUI_NumberValue value0[] = {};
4298     ArkUI_AttributeItem item0 = {value0, 0, nullptr, nullptr};
4299     ArkUI_NumberValue value[] = {{.f32 = negativeFloat}};
4300     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
4301     ArkUI_NumberValue value3[] = {{.u32 = 2024}, {.u32 = 13}, {.u32 = 1}};
4302     ArkUI_AttributeItem item3 = {value3, sizeof(value3) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
4303     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CALENDAR_PICKER_HINT_RADIUS, &item0),
4304         ARKUI_ERROR_CODE_PARAM_INVALID);
4305     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CALENDAR_PICKER_HINT_RADIUS, &item),
4306         ARKUI_ERROR_CODE_PARAM_INVALID);
4307     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CALENDAR_PICKER_SELECTED_DATE, &item0),
4308         ARKUI_ERROR_CODE_PARAM_INVALID);
4309     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CALENDAR_PICKER_SELECTED_DATE, &item3),
4310         ARKUI_ERROR_CODE_PARAM_INVALID);
4311     value3[1].u32 = 12;
4312     value3[2].u32 = 40;
4313     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CALENDAR_PICKER_SELECTED_DATE, &item3),
4314         ARKUI_ERROR_CODE_PARAM_INVALID);
4315     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CALENDAR_PICKER_EDGE_ALIGNMENT, &item0),
4316         ARKUI_ERROR_CODE_PARAM_INVALID);
4317     value[0].i32 = negativeInt;
4318     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CALENDAR_PICKER_EDGE_ALIGNMENT, &item),
4319         ARKUI_ERROR_CODE_PARAM_INVALID);
4320     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CALENDAR_PICKER_TEXT_STYLE, &item0),
4321         ARKUI_ERROR_CODE_NO_ERROR);
4322     value3[1].f32 = negativeFloat;
4323     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CALENDAR_PICKER_TEXT_STYLE, &item3),
4324         ARKUI_ERROR_CODE_PARAM_INVALID);
4325     value3[1].f32 = 1.0f;
4326     value3[2].i32 = negativeInt;
4327     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_CALENDAR_PICKER_TEXT_STYLE, &item3),
4328         ARKUI_ERROR_CODE_PARAM_INVALID);
4329     nodeAPI->disposeNode(rootNode);
4330 }
4331 
4332 /**
4333  * @tc.name: NativeNodeTest055
4334  * @tc.desc: Test abnormalInputForSlider function.
4335  * @tc.type: FUNC
4336  */
HWTEST_F(NativeNodeTest, NativeNodeTest055, TestSize.Level1)4337 HWTEST_F(NativeNodeTest, NativeNodeTest055, TestSize.Level1)
4338 {
4339     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
4340         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
4341     auto rootNode = nodeAPI->createNode(ARKUI_NODE_SLIDER);
4342     float negativeFloat = -1.0f;
4343     ArkUI_NumberValue value0[] = {};
4344     ArkUI_AttributeItem item0 = {value0, 0, nullptr, nullptr};
4345     ArkUI_NumberValue value[] = {{.i32 = ARKUI_SLIDER_BLOCK_STYLE_IMAGE }, {.i32 = ARKUI_CLIP_TYPE_PATH},
4346         {.f32 = negativeFloat}, {.f32 = negativeFloat}, {.f32 = negativeFloat}};
4347     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
4348     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SLIDER_BLOCK_COLOR, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4349     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SLIDER_TRACK_COLOR, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4350     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SLIDER_SELECTED_COLOR, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4351     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SLIDER_SHOW_STEPS, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4352     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SLIDER_VALUE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4353     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SLIDER_MIN_VALUE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4354     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SLIDER_MAX_VALUE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4355     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SLIDER_STEP, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4356     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SLIDER_DIRECTION, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4357     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SLIDER_REVERSE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4358     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SLIDER_STYLE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4359     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SLIDER_TRACK_THICKNESS, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4360     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SLIDER_BLOCK_STYLE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4361     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SLIDER_BLOCK_STYLE, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4362     value[0].i32 = ARKUI_SLIDER_BLOCK_STYLE_SHAPE;
4363     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SLIDER_BLOCK_STYLE, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4364     value[1].i32 = ARKUI_CLIP_TYPE_RECTANGLE;
4365     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SLIDER_BLOCK_STYLE, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4366     value[0].i32 = -1;
4367     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SLIDER_SHOW_STEPS, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4368     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SLIDER_DIRECTION, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4369     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SLIDER_REVERSE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4370     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SLIDER_STYLE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4371     value[0].f32 = -1.0f;
4372     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SLIDER_STEP, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4373     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SLIDER_TRACK_THICKNESS, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4374     nodeAPI->disposeNode(rootNode);
4375 }
4376 
4377 /**
4378  * @tc.name: NativeNodeTest056
4379  * @tc.desc: Test abnormalInputForRadio function.
4380  * @tc.type: FUNC
4381  */
HWTEST_F(NativeNodeTest, NativeNodeTest056, TestSize.Level1)4382 HWTEST_F(NativeNodeTest, NativeNodeTest056, TestSize.Level1)
4383 {
4384     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
4385         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
4386     auto rootNode = nodeAPI->createNode(ARKUI_NODE_RADIO);
4387     ArkUI_NumberValue value0[] = {};
4388     ArkUI_AttributeItem item0 = {value0, 0, nullptr, nullptr};
4389     ArkUI_NumberValue value[] = {{.i32 = -1 }};
4390     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
4391     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_RADIO_CHECKED, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4392     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_RADIO_CHECKED, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4393     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_RADIO_STYLE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4394     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_RADIO_VALUE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4395     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_RADIO_GROUP, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4396     item0.size = -1;
4397     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_RADIO_STYLE, &item0), ARKUI_ERROR_CODE_NO_ERROR);
4398     nodeAPI->disposeNode(rootNode);
4399 }
4400 
4401 /**
4402  * @tc.name: NativeNodeTest057
4403  * @tc.desc: Test abnormalInputForStack function.
4404  * @tc.type: FUNC
4405  */
HWTEST_F(NativeNodeTest, NativeNodeTest057, TestSize.Level1)4406 HWTEST_F(NativeNodeTest, NativeNodeTest057, TestSize.Level1)
4407 {
4408     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
4409         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
4410     auto rootNode = nodeAPI->createNode(ARKUI_NODE_STACK);
4411     ArkUI_NumberValue value0[] = {};
4412     ArkUI_AttributeItem item0 = {value0, 0, nullptr, nullptr};
4413     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_STACK_ALIGN_CONTENT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4414     nodeAPI->disposeNode(rootNode);
4415 }
4416 
4417 /**
4418  * @tc.name: NativeNodeTest058
4419  * @tc.desc: Test abnormalInputForScroll function.
4420  * @tc.type: FUNC
4421  */
HWTEST_F(NativeNodeTest, NativeNodeTest058, TestSize.Level1)4422 HWTEST_F(NativeNodeTest, NativeNodeTest058, TestSize.Level1)
4423 {
4424     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
4425         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
4426     auto rootNode = nodeAPI->createNode(ARKUI_NODE_SCROLL);
4427     float negativeFloat = -1.0f;
4428     int32_t negativeInt = -1;
4429     ArkUI_NumberValue value0[] = {};
4430     ArkUI_AttributeItem item0 = {value0, 0, nullptr, nullptr};
4431     ArkUI_NumberValue value[] = {{.i32 = negativeInt }, {.i32 = negativeInt},
4432         {.i32 = negativeInt}, {.f32 = negativeFloat}, {.f32 = negativeFloat}};
4433     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
4434     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCROLL_BAR_DISPLAY_MODE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4435     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCROLL_BAR_WIDTH, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4436     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCROLL_BAR_COLOR, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4437     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCROLL_SCROLL_DIRECTION, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4438     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCROLL_SCROLL_DIRECTION, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4439     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCROLL_EDGE_EFFECT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4440     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCROLL_EDGE_EFFECT, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4441     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCROLL_ENABLE_SCROLL_INTERACTION, &item0),
4442         ARKUI_ERROR_CODE_PARAM_INVALID);
4443     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCROLL_ENABLE_SCROLL_INTERACTION, &item),
4444         ARKUI_ERROR_CODE_PARAM_INVALID);
4445     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCROLL_FRICTION, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4446     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCROLL_SNAP, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4447     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCROLL_SNAP, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4448     value[0].i32 = ARKUI_SCROLL_SNAP_ALIGN_NONE;
4449     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCROLL_SNAP, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4450     value[1].i32 = true;
4451     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCROLL_SNAP, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4452     value[2].i32 = true;
4453     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCROLL_SNAP, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4454     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCROLL_NESTED_SCROLL, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4455     value[0].i32 = negativeInt;
4456     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCROLL_NESTED_SCROLL, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4457     value[0].i32 = ARKUI_SCROLL_NESTED_MODE_SELF_ONLY;
4458     value[1].i32 = negativeInt;
4459     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCROLL_NESTED_SCROLL, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4460     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCROLL_EDGE_EFFECT, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4461     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCROLL_OFFSET, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4462     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCROLL_EDGE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4463     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCROLL_ENABLE_PAGING, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4464     value[0].i32 = negativeInt;
4465     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCROLL_ENABLE_PAGING, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4466     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCROLL_PAGE, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4467     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCROLL_PAGE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4468     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCROLL_BY, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4469     value[0].f32 = negativeFloat;
4470     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SCROLL_FRICTION, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4471     nodeAPI->disposeNode(rootNode);
4472 }
4473 
4474 /**
4475  * @tc.name: NativeNodeTest059
4476  * @tc.desc: Test abnormalInputForList function.
4477  * @tc.type: FUNC
4478  */
HWTEST_F(NativeNodeTest, NativeNodeTest059, TestSize.Level1)4479 HWTEST_F(NativeNodeTest, NativeNodeTest059, TestSize.Level1)
4480 {
4481     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
4482         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
4483     auto rootNode = new ArkUI_Node({ARKUI_NODE_LIST, nullptr});
4484     auto childNode = new ArkUI_Node({ARKUI_NODE_LIST_ITEM, nullptr});
4485     auto childNodeNew = new ArkUI_Node({ARKUI_NODE_LIST_ITEM, nullptr});
4486     auto groupNode = new ArkUI_Node({ARKUI_NODE_LIST_ITEM_GROUP, nullptr});
4487 
4488     nodeAPI->insertChildAt(rootNode, groupNode, 0);
4489     nodeAPI->insertChildAfter(groupNode, childNodeNew, nullptr);
4490     nodeAPI->insertChildBefore(groupNode, childNode, childNodeNew);
4491     float negativeFloat = -1.0f;
4492     int32_t negativeInt = -1;
4493     ArkUI_NumberValue value0[] = {};
4494     ArkUI_AttributeItem item0 = {value0, 0, nullptr, nullptr};
4495     ArkUI_NumberValue value[] = {{.i32 = negativeInt }, {.i32 = negativeInt},
4496         {.i32 = negativeInt}, {.f32 = negativeFloat}, {.f32 = negativeFloat}};
4497     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
4498     ArkUI_NumberValue valueEnum[] = {{.i32 = negativeInt}};
4499     ArkUI_AttributeItem itemEnum = {valueEnum, 1, nullptr, nullptr};
4500     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LIST_DIRECTION, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4501     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LIST_DIRECTION, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4502     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LIST_STICKY, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4503     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LIST_STICKY, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4504     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LIST_SPACE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4505     value[0].f32 = negativeFloat;
4506     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LIST_SPACE, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4507     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LIST_NODE_ADAPTER, nullptr), ARKUI_ERROR_CODE_PARAM_INVALID);
4508     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LIST_NODE_ADAPTER, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4509     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LIST_CACHED_COUNT, nullptr), ARKUI_ERROR_CODE_PARAM_INVALID);
4510     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LIST_CACHED_COUNT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4511     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LIST_CACHED_COUNT, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4512     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LIST_SCROLL_TO_INDEX, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4513     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LIST_ALIGN_LIST_ITEM, nullptr), ARKUI_ERROR_CODE_PARAM_INVALID);
4514     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LIST_ALIGN_LIST_ITEM, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4515     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LIST_ALIGN_LIST_ITEM, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4516     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LIST_CHILDREN_MAIN_SIZE, nullptr), ARKUI_ERROR_CODE_PARAM_INVALID);
4517     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LIST_CHILDREN_MAIN_SIZE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4518     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LIST_INITIAL_INDEX, nullptr), ARKUI_ERROR_CODE_PARAM_INVALID);
4519     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LIST_INITIAL_INDEX, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4520     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LIST_INITIAL_INDEX, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4521     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LIST_DIVIDER, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4522     value[1].f32 = negativeFloat;
4523     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LIST_DIVIDER, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4524     EXPECT_EQ(nodeAPI->setAttribute(groupNode, NODE_LIST_ITEM_GROUP_SET_DIVIDER, &item),
4525         ARKUI_ERROR_CODE_PARAM_INVALID);
4526     value[1].f32 = 0.0f;
4527     value[2].f32 = negativeFloat;
4528     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LIST_DIVIDER, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4529     EXPECT_EQ(nodeAPI->setAttribute(groupNode, NODE_LIST_ITEM_GROUP_SET_DIVIDER, &item),
4530         ARKUI_ERROR_CODE_PARAM_INVALID);
4531     value[2].f32 = 0.0f;
4532     value[3].f32 = negativeFloat;
4533     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_LIST_DIVIDER, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4534     EXPECT_EQ(nodeAPI->setAttribute(groupNode, NODE_LIST_ITEM_GROUP_SET_DIVIDER, &item),
4535         ARKUI_ERROR_CODE_PARAM_INVALID);
4536     EXPECT_EQ(nodeAPI->setAttribute(childNode, NODE_LIST_ITEM_SWIPE_ACTION, nullptr), ARKUI_ERROR_CODE_PARAM_INVALID);
4537     EXPECT_EQ(nodeAPI->setAttribute(childNode, NODE_LIST_ITEM_SWIPE_ACTION, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4538     EXPECT_EQ(nodeAPI->setAttribute(groupNode, NODE_LIST_ITEM_GROUP_SET_HEADER, &item0),
4539         ARKUI_ERROR_CODE_PARAM_INVALID);
4540     EXPECT_EQ(nodeAPI->setAttribute(groupNode, NODE_LIST_ITEM_GROUP_SET_FOOTER, &item0),
4541         ARKUI_ERROR_CODE_PARAM_INVALID);
4542     EXPECT_EQ(nodeAPI->setAttribute(groupNode, NODE_LIST_ITEM_GROUP_SET_DIVIDER, &item0),
4543         ARKUI_ERROR_CODE_PARAM_INVALID);
4544     EXPECT_EQ(nodeAPI->setAttribute(groupNode, NODE_LIST_ITEM_GROUP_CHILDREN_MAIN_SIZE, nullptr),
4545         ARKUI_ERROR_CODE_PARAM_INVALID);
4546     EXPECT_EQ(nodeAPI->setAttribute(groupNode, NODE_LIST_ITEM_GROUP_CHILDREN_MAIN_SIZE, &item0),
4547         ARKUI_ERROR_CODE_PARAM_INVALID);
4548     nodeAPI->removeChild(groupNode, childNode);
4549     nodeAPI->disposeNode(rootNode);
4550     nodeAPI->disposeNode(groupNode);
4551     nodeAPI->disposeNode(childNode);
4552 }
4553 
4554 /**
4555  * @tc.name: NativeNodeTest060
4556  * @tc.desc: Test abnormalInputForSwiper function.
4557  * @tc.type: FUNC
4558  */
HWTEST_F(NativeNodeTest, NativeNodeTest060, TestSize.Level1)4559 HWTEST_F(NativeNodeTest, NativeNodeTest060, TestSize.Level1)
4560 {
4561     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
4562         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
4563     auto rootNode = new ArkUI_Node({ARKUI_NODE_SWIPER, nullptr});
4564     float negativeFloat = -1.0f;
4565     int32_t negativeInt = -1;
4566     ArkUI_NumberValue value0[] = {};
4567     ArkUI_AttributeItem item0 = {value0, 0, nullptr, nullptr};
4568     ArkUI_NumberValue valueEnum[] = {{.i32 = negativeInt}};
4569     ArkUI_AttributeItem itemEnum = {valueEnum, 1, nullptr, nullptr};
4570     ArkUI_NumberValue valueFloat[] = {{.f32 = negativeFloat}};
4571     ArkUI_AttributeItem itemFloat = {valueFloat, 1, nullptr, nullptr};
4572     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_LOOP, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4573     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_LOOP, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4574     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_AUTO_PLAY, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4575     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_AUTO_PLAY, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4576     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_SHOW_INDICATOR, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4577     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_SHOW_INDICATOR, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4578     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_INTERVAL, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4579     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_INTERVAL, &itemFloat), ARKUI_ERROR_CODE_PARAM_INVALID);
4580     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_VERTICAL, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4581     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_VERTICAL, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4582     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_DURATION, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4583     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_DURATION, &itemFloat), ARKUI_ERROR_CODE_PARAM_INVALID);
4584     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_CURVE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4585     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_CURVE, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4586     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_ITEM_SPACE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4587     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_ITEM_SPACE, &itemFloat), ARKUI_ERROR_CODE_PARAM_INVALID);
4588     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_INDEX, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4589     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_INDEX, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4590     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_DISPLAY_COUNT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4591     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_DISABLE_SWIPE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4592     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_DISABLE_SWIPE, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4593     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_SHOW_DISPLAY_ARROW, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4594     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_SHOW_DISPLAY_ARROW, &itemFloat),
4595         ARKUI_ERROR_CODE_PARAM_INVALID);
4596     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_EDGE_EFFECT_MODE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4597     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_EDGE_EFFECT_MODE, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4598     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_NODE_ADAPTER, nullptr), ARKUI_ERROR_CODE_PARAM_INVALID);
4599     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_NODE_ADAPTER, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4600     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_CACHED_COUNT, nullptr), ARKUI_ERROR_CODE_PARAM_INVALID);
4601     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_CACHED_COUNT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4602     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_CACHED_COUNT, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4603     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_PREV_MARGIN, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4604     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_PREV_MARGIN, &itemFloat), ARKUI_ERROR_CODE_PARAM_INVALID);
4605     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_NEXT_MARGIN, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4606     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_NEXT_MARGIN, &itemFloat), ARKUI_ERROR_CODE_PARAM_INVALID);
4607     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_INDICATOR, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4608     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_INDICATOR, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4609     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_INDICATOR_INTERACTIVE, &item0),
4610         ARKUI_ERROR_CODE_PARAM_INVALID);
4611     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_NESTED_SCROLL, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4612     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_NESTED_SCROLL, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4613     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_SWIPE_TO_INDEX, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4614     valueEnum[0].i32 = ARKUI_SWIPER_INDICATOR_TYPE_DOT;
4615     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_SWIPER_INDICATOR, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4616     nodeAPI->disposeNode(rootNode);
4617 }
4618 
4619 /**
4620  * @tc.name: NativeNodeTest061
4621  * @tc.desc: Test abnormalInputForColumn function.
4622  * @tc.type: FUNC
4623  */
HWTEST_F(NativeNodeTest, NativeNodeTest061, TestSize.Level1)4624 HWTEST_F(NativeNodeTest, NativeNodeTest061, TestSize.Level1)
4625 {
4626     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
4627         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
4628     auto rootNode = nodeAPI->createNode(ARKUI_NODE_COLUMN);
4629     int32_t negativeInt = -1;
4630     ArkUI_NumberValue value0[] = {};
4631     ArkUI_AttributeItem item0 = {value0, 0, nullptr, nullptr};
4632     ArkUI_NumberValue valueEnum[] = {{.i32 = negativeInt}};
4633     ArkUI_AttributeItem itemEnum = {valueEnum, 1, nullptr, nullptr};
4634     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_COLUMN_ALIGN_ITEMS, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4635     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_COLUMN_ALIGN_ITEMS, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4636     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_COLUMN_JUSTIFY_CONTENT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4637     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_COLUMN_JUSTIFY_CONTENT, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4638     nodeAPI->disposeNode(rootNode);
4639 }
4640 
4641 /**
4642  * @tc.name: NativeNodeTest062
4643  * @tc.desc: Test abnormalInputForRow function.
4644  * @tc.type: FUNC
4645  */
HWTEST_F(NativeNodeTest, NativeNodeTest062, TestSize.Level1)4646 HWTEST_F(NativeNodeTest, NativeNodeTest062, TestSize.Level1)
4647 {
4648     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
4649         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
4650     auto rootNode = nodeAPI->createNode(ARKUI_NODE_ROW);
4651     ASSERT_NE(rootNode, nullptr);
4652     int32_t negativeInt = -1;
4653     ArkUI_NumberValue value0[] = {};
4654     ArkUI_AttributeItem item0 = {value0, 0, nullptr, nullptr};
4655     ArkUI_NumberValue valueEnum[] = {{.i32 = negativeInt}};
4656     ArkUI_AttributeItem itemEnum = {valueEnum, 1, nullptr, nullptr};
4657     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_ROW_ALIGN_ITEMS, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4658     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_ROW_ALIGN_ITEMS, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4659     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_ROW_JUSTIFY_CONTENT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4660     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_ROW_JUSTIFY_CONTENT, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4661     nodeAPI->disposeNode(rootNode);
4662 }
4663 
4664 /**
4665  * @tc.name: NativeNodeTest063
4666  * @tc.desc: Test abnormalInputForRefresh function.
4667  * @tc.type: FUNC
4668  */
HWTEST_F(NativeNodeTest, NativeNodeTest063, TestSize.Level1)4669 HWTEST_F(NativeNodeTest, NativeNodeTest063, TestSize.Level1)
4670 {
4671     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
4672         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
4673     auto rootNode = nodeAPI->createNode(ARKUI_NODE_REFRESH);
4674     ASSERT_NE(rootNode, nullptr);
4675     float negativeFloat = -1.0f;
4676     int32_t negativeInt = -1;
4677     ArkUI_NumberValue value0[] = {};
4678     ArkUI_AttributeItem item0 = {value0, 0, nullptr, nullptr};
4679     ArkUI_NumberValue valueEnum[] = {{.i32 = negativeInt}};
4680     ArkUI_AttributeItem itemEnum = {valueEnum, 1, nullptr, nullptr};
4681     ArkUI_NumberValue valueFloat[] = {{.f32 = negativeFloat}};
4682     ArkUI_AttributeItem itemFloat = {valueFloat, 1, nullptr, nullptr};
4683     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_REFRESH_REFRESHING, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4684     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_REFRESH_REFRESHING, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4685     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_REFRESH_CONTENT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4686     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_REFRESH_PULL_DOWN_RATIO, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4687     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_REFRESH_PULL_DOWN_RATIO, &itemFloat),
4688         ARKUI_ERROR_CODE_PARAM_INVALID);
4689     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_REFRESH_OFFSET, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4690     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_REFRESH_OFFSET, &itemFloat), ARKUI_ERROR_CODE_PARAM_INVALID);
4691     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_REFRESH_PULL_TO_REFRESH, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4692     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_REFRESH_PULL_TO_REFRESH, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4693     valueFloat[0].f32 = 2.0f;
4694     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_REFRESH_PULL_DOWN_RATIO, &itemFloat),
4695         ARKUI_ERROR_CODE_PARAM_INVALID);
4696     nodeAPI->disposeNode(rootNode);
4697 }
4698 
4699 /**
4700  * @tc.name: NativeNodeTest064
4701  * @tc.desc: Test abnormalInputForWaterflow function.
4702  * @tc.type: FUNC
4703  */
HWTEST_F(NativeNodeTest, NativeNodeTest064, TestSize.Level1)4704 HWTEST_F(NativeNodeTest, NativeNodeTest064, TestSize.Level1)
4705 {
4706     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
4707         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
4708     auto rootNode = nodeAPI->createNode(ARKUI_NODE_WATER_FLOW);
4709     ASSERT_NE(rootNode, nullptr);
4710     float negativeFloat = -1.0f;
4711     int32_t negativeInt = -1;
4712     ArkUI_NumberValue value0[] = {};
4713     ArkUI_AttributeItem item0 = {value0, 0, nullptr, nullptr};
4714     ArkUI_NumberValue valueEnum[] = {{.i32 = negativeInt}};
4715     ArkUI_AttributeItem itemEnum = {valueEnum, 1, nullptr, nullptr};
4716     ArkUI_NumberValue valueFloat[] = {{.f32 = negativeFloat}, {.f32 = negativeFloat}, {.f32 = negativeFloat},
4717         {.f32 = negativeFloat}};
4718     ArkUI_AttributeItem itemFloat = {valueFloat, sizeof(valueFloat) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
4719     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_LAYOUT_DIRECTION, &item0),
4720         ARKUI_ERROR_CODE_PARAM_INVALID);
4721     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_LAYOUT_DIRECTION, &itemEnum),
4722         ARKUI_ERROR_CODE_PARAM_INVALID);
4723     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_COLUMN_TEMPLATE, &item0),
4724         ARKUI_ERROR_CODE_PARAM_INVALID);
4725     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_ROW_TEMPLATE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4726     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_COLUMN_GAP, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4727     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_COLUMN_GAP, &itemFloat), ARKUI_ERROR_CODE_PARAM_INVALID);
4728     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_ROW_GAP, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4729     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_ROW_GAP, &itemFloat), ARKUI_ERROR_CODE_PARAM_INVALID);
4730     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_SECTION_OPTION, nullptr), ARKUI_ERROR_CODE_PARAM_INVALID);
4731     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_SECTION_OPTION, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4732     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_SECTION_OPTION, &itemFloat),
4733         ARKUI_ERROR_CODE_PARAM_INVALID);
4734     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_NODE_ADAPTER, nullptr), ARKUI_ERROR_CODE_PARAM_INVALID);
4735     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_NODE_ADAPTER, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4736     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_CACHED_COUNT, nullptr), ARKUI_ERROR_CODE_PARAM_INVALID);
4737     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_CACHED_COUNT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4738     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_CACHED_COUNT, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4739     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_FOOTER, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4740     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_SCROLL_TO_INDEX, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4741     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_ITEM_CONSTRAINT_SIZE, &item0),
4742         ARKUI_ERROR_CODE_PARAM_INVALID);
4743     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_ITEM_CONSTRAINT_SIZE, &itemEnum),
4744         ARKUI_ERROR_CODE_PARAM_INVALID);
4745     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_WATER_FLOW_ITEM_CONSTRAINT_SIZE, &itemFloat),
4746         ARKUI_ERROR_CODE_PARAM_INVALID);
4747     nodeAPI->disposeNode(rootNode);
4748 }
4749 
4750 /**
4751  * @tc.name: NativeNodeTest065
4752  * @tc.desc: Test abnormalInputForGrid function.
4753  * @tc.type: FUNC
4754  */
HWTEST_F(NativeNodeTest, NativeNodeTest065, TestSize.Level1)4755 HWTEST_F(NativeNodeTest, NativeNodeTest065, TestSize.Level1)
4756 {
4757     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
4758         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
4759     auto rootNode = nodeAPI->createNode(ARKUI_NODE_GRID);
4760     ASSERT_NE(rootNode, nullptr);
4761     float negativeFloat = -1.0f;
4762     int32_t negativeInt = -1;
4763     ArkUI_NumberValue value0[] = {};
4764     ArkUI_AttributeItem item0 = {value0, 0, nullptr, nullptr};
4765     ArkUI_NumberValue valueEnum[] = {{.i32 = negativeInt}};
4766     ArkUI_AttributeItem itemEnum = {valueEnum, 1, nullptr, nullptr};
4767     ArkUI_NumberValue valueFloat[] = {{.f32 = negativeFloat}, {.f32 = negativeFloat}, {.f32 = negativeFloat},
4768         {.f32 = negativeFloat}};
4769     ArkUI_AttributeItem itemFloat = {valueFloat, sizeof(valueFloat) / sizeof(ArkUI_NumberValue), nullptr, nullptr};
4770     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_GRID_COLUMN_TEMPLATE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4771     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_GRID_ROW_TEMPLATE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4772     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_GRID_COLUMN_GAP, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4773     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_GRID_COLUMN_GAP, &itemFloat), ARKUI_ERROR_CODE_PARAM_INVALID);
4774     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_GRID_ROW_GAP, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4775     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_GRID_ROW_GAP, &itemFloat), ARKUI_ERROR_CODE_PARAM_INVALID);
4776     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_GRID_NODE_ADAPTER, nullptr), ARKUI_ERROR_CODE_PARAM_INVALID);
4777     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_GRID_NODE_ADAPTER, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4778     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_GRID_CACHED_COUNT, nullptr), ARKUI_ERROR_CODE_PARAM_INVALID);
4779     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_GRID_CACHED_COUNT, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4780     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_GRID_CACHED_COUNT, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4781     nodeAPI->disposeNode(rootNode);
4782 }
4783 
4784 /**
4785  * @tc.name: NativeNodeTest066
4786  * @tc.desc: Test abnormalInputForImageAnimator function.
4787  * @tc.type: FUNC
4788  */
HWTEST_F(NativeNodeTest, NativeNodeTest066, TestSize.Level1)4789 HWTEST_F(NativeNodeTest, NativeNodeTest066, TestSize.Level1)
4790 {
4791     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
4792         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
4793     auto rootNode = nodeAPI->createNode(ARKUI_NODE_IMAGE_ANIMATOR);
4794     ASSERT_NE(rootNode, nullptr);
4795     int32_t negativeInt = -1;
4796     ArkUI_NumberValue value0[] = {};
4797     ArkUI_AttributeItem item0 = {value0, 0, nullptr, nullptr};
4798     ArkUI_NumberValue valueEnum[] = {{.i32 = negativeInt}};
4799     ArkUI_AttributeItem itemEnum = {valueEnum, 1, nullptr, nullptr};
4800     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_ANIMATOR_IMAGES, nullptr), ARKUI_ERROR_CODE_PARAM_INVALID);
4801     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_ANIMATOR_IMAGES, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4802     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_ANIMATOR_STATE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4803     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_ANIMATOR_STATE, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4804     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_ANIMATOR_DURATION, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4805     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_ANIMATOR_REVERSE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4806     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_ANIMATOR_REVERSE, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4807     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_ANIMATOR_FIXED_SIZE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4808     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_ANIMATOR_FIXED_SIZE, &itemEnum),
4809         ARKUI_ERROR_CODE_PARAM_INVALID);
4810     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_ANIMATOR_FILL_MODE, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4811     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_ANIMATOR_FILL_MODE, &itemEnum),
4812         ARKUI_ERROR_CODE_PARAM_INVALID);
4813     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_ANIMATOR_ITERATION, &item0), ARKUI_ERROR_CODE_PARAM_INVALID);
4814     valueEnum[0].i32 = 4;
4815     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_ANIMATOR_STATE, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4816     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_ANIMATOR_REVERSE, &itemEnum), ARKUI_ERROR_CODE_PARAM_INVALID);
4817     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_ANIMATOR_FIXED_SIZE, &itemEnum),
4818         ARKUI_ERROR_CODE_PARAM_INVALID);
4819     EXPECT_EQ(nodeAPI->setAttribute(rootNode, NODE_IMAGE_ANIMATOR_FILL_MODE, &itemEnum),
4820         ARKUI_ERROR_CODE_PARAM_INVALID);
4821     nodeAPI->disposeNode(rootNode);
4822 }
4823 
4824 /**
4825  * @tc.name: NativeNodeTest067
4826  * @tc.desc: Test attributeAbnormal function.
4827  * @tc.type: FUNC
4828  */
HWTEST_F(NativeNodeTest, NativeNodeTest067, TestSize.Level1)4829 HWTEST_F(NativeNodeTest, NativeNodeTest067, TestSize.Level1)
4830 {
4831     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
4832         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
4833     int32_t abnormalType = static_cast<int32_t>(ARKUI_NODE_CUSTOM_SPAN) + 1;
4834     EXPECT_EQ(nodeAPI->createNode(static_cast<ArkUI_NodeType>(abnormalType)), nullptr);
4835     nodeAPI->disposeNode(nullptr);
4836     EXPECT_EQ(nodeAPI->addChild(nullptr, nullptr), ARKUI_ERROR_CODE_PARAM_INVALID);
4837     EXPECT_EQ(nodeAPI->removeChild(nullptr, nullptr), ARKUI_ERROR_CODE_PARAM_INVALID);
4838     EXPECT_EQ(nodeAPI->insertChildAfter(nullptr, nullptr, nullptr), ARKUI_ERROR_CODE_PARAM_INVALID);
4839     EXPECT_EQ(nodeAPI->insertChildBefore(nullptr, nullptr, nullptr), ARKUI_ERROR_CODE_PARAM_INVALID);
4840     EXPECT_EQ(nodeAPI->insertChildAt(nullptr, nullptr, 0), ARKUI_ERROR_CODE_PARAM_INVALID);
4841     EXPECT_EQ(nodeAPI->setAttribute(nullptr, NODE_WIDTH, nullptr), ARKUI_ERROR_CODE_PARAM_INVALID);
4842     EXPECT_EQ(nodeAPI->resetAttribute(nullptr, NODE_WIDTH), ARKUI_ERROR_CODE_PARAM_INVALID);
4843     EXPECT_EQ(nodeAPI->getAttribute(nullptr, NODE_WIDTH), nullptr);
4844     auto abnormalNode = new ArkUI_Node({-1, nullptr});
4845     EXPECT_EQ(nodeAPI->addChild(abnormalNode, abnormalNode), ARKUI_ERROR_CODE_NOT_SUPPROTED_FOR_ARKTS_NODE);
4846     EXPECT_EQ(nodeAPI->removeChild(abnormalNode, abnormalNode), ARKUI_ERROR_CODE_NOT_SUPPROTED_FOR_ARKTS_NODE);
4847     EXPECT_EQ(nodeAPI->insertChildAfter(abnormalNode, abnormalNode, nullptr),
4848         ARKUI_ERROR_CODE_NOT_SUPPROTED_FOR_ARKTS_NODE);
4849     EXPECT_EQ(nodeAPI->insertChildBefore(abnormalNode, abnormalNode, nullptr),
4850         ARKUI_ERROR_CODE_NOT_SUPPROTED_FOR_ARKTS_NODE);
4851     EXPECT_EQ(nodeAPI->insertChildAt(abnormalNode, abnormalNode, 0), ARKUI_ERROR_CODE_NOT_SUPPROTED_FOR_ARKTS_NODE);
4852     EXPECT_EQ(nodeAPI->setAttribute(abnormalNode, NODE_WIDTH, nullptr), ARKUI_ERROR_CODE_NOT_SUPPROTED_FOR_ARKTS_NODE);
4853     EXPECT_EQ(nodeAPI->resetAttribute(abnormalNode, NODE_WIDTH), ARKUI_ERROR_CODE_NOT_SUPPROTED_FOR_ARKTS_NODE);
4854     int32_t abnormalAttribute = 999 * MAX_NODE_SCOPE_NUM;
4855     auto node = nodeAPI->createNode(ARKUI_NODE_STACK);
4856     EXPECT_EQ(nodeAPI->setAttribute(node, static_cast<ArkUI_NodeAttributeType>(abnormalAttribute), nullptr),
4857         ARKUI_ERROR_CODE_ATTRIBUTE_OR_EVENT_NOT_SUPPORTED);
4858     EXPECT_EQ(nodeAPI->resetAttribute(node, static_cast<ArkUI_NodeAttributeType>(abnormalAttribute)),
4859         ARKUI_ERROR_CODE_ATTRIBUTE_OR_EVENT_NOT_SUPPORTED);
4860     EXPECT_EQ(nodeAPI->getAttribute(node, static_cast<ArkUI_NodeAttributeType>(abnormalAttribute)), nullptr);
4861     for (int32_t i = 0; i <= static_cast<int32_t>(ARKUI_NODE_IMAGE_ANIMATOR); i++) {
4862         abnormalAttribute = (i + 1) * MAX_NODE_SCOPE_NUM - 1;
4863         EXPECT_EQ(nodeAPI->setAttribute(node, static_cast<ArkUI_NodeAttributeType>(abnormalAttribute), nullptr),
4864             ARKUI_ERROR_CODE_ATTRIBUTE_OR_EVENT_NOT_SUPPORTED);
4865         EXPECT_EQ(nodeAPI->resetAttribute(node, static_cast<ArkUI_NodeAttributeType>(abnormalAttribute)),
4866             ARKUI_ERROR_CODE_NO_ERROR);
4867         if (i == ARKUI_NODE_DATE_PICKER || i == ARKUI_NODE_TEXT_PICKER || i == ARKUI_NODE_TIME_PICKER ||
4868             i == ARKUI_NODE_LOADING_PROGRESS) {
4869             EXPECT_NE(nodeAPI->getAttribute(node, static_cast<ArkUI_NodeAttributeType>(abnormalAttribute)), nullptr);
4870         } else {
4871             EXPECT_EQ(nodeAPI->getAttribute(node, static_cast<ArkUI_NodeAttributeType>(abnormalAttribute)), nullptr);
4872         }
4873     }
4874     for (int32_t j = static_cast<int32_t>(ARKUI_NODE_STACK); j < static_cast<int32_t>(ARKUI_NODE_GRID_ITEM); j++) {
4875         abnormalAttribute = (j + 1) * MAX_NODE_SCOPE_NUM - 1;
4876         if (j == ARKUI_NODE_FLOW_ITEM) {
4877             EXPECT_EQ(nodeAPI->setAttribute(node, static_cast<ArkUI_NodeAttributeType>(abnormalAttribute), nullptr),
4878                 ARKUI_ERROR_CODE_PARAM_INVALID);
4879             EXPECT_EQ(nodeAPI->resetAttribute(node, static_cast<ArkUI_NodeAttributeType>(abnormalAttribute)),
4880                 ARKUI_ERROR_CODE_PARAM_INVALID);
4881             EXPECT_EQ(nodeAPI->getAttribute(node, static_cast<ArkUI_NodeAttributeType>(abnormalAttribute)), nullptr);
4882         } else {
4883             EXPECT_EQ(nodeAPI->setAttribute(node, static_cast<ArkUI_NodeAttributeType>(abnormalAttribute), nullptr),
4884                 ARKUI_ERROR_CODE_ATTRIBUTE_OR_EVENT_NOT_SUPPORTED);
4885             EXPECT_EQ(nodeAPI->resetAttribute(node, static_cast<ArkUI_NodeAttributeType>(abnormalAttribute)),
4886                 ARKUI_ERROR_CODE_NO_ERROR);
4887             if (j == ARKUI_NODE_LIST) {
4888                 EXPECT_NE(nodeAPI->getAttribute(
4889                     node, static_cast<ArkUI_NodeAttributeType>(abnormalAttribute)), nullptr);
4890             } else {
4891                 EXPECT_EQ(nodeAPI->getAttribute(
4892                     node, static_cast<ArkUI_NodeAttributeType>(abnormalAttribute)), nullptr);
4893             }
4894         }
4895     }
4896     delete abnormalNode;
4897     abnormalNode = nullptr;
4898     nodeAPI->disposeNode(node);
4899 }
4900 
4901 /**
4902  * @tc.name: NativeNodeTest068
4903  * @tc.desc: Test eventAbnormal function.
4904  * @tc.type: FUNC
4905  */
HWTEST_F(NativeNodeTest, NativeNodeTest068, TestSize.Level1)4906 HWTEST_F(NativeNodeTest, NativeNodeTest068, TestSize.Level1)
4907 {
4908     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
4909         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
4910     auto node = nodeAPI->createNode(ARKUI_NODE_STACK);
4911     EXPECT_EQ(nodeAPI->registerNodeEvent(nullptr, NODE_TOUCH_EVENT, 0, nullptr), ARKUI_ERROR_CODE_PARAM_INVALID);
4912     EXPECT_EQ(nodeAPI->registerNodeEvent(
4913         node, static_cast<ArkUI_NodeEventType>(-1), 0, nullptr), ARKUI_ERROR_CODE_ATTRIBUTE_OR_EVENT_NOT_SUPPORTED);
4914     nodeAPI->unregisterNodeEvent(nullptr, NODE_TOUCH_EVENT);
4915     nodeAPI->unregisterNodeEvent(node, NODE_TOUCH_EVENT);
4916     nodeAPI->disposeNode(node);
4917 }
4918 
4919 /**
4920  * @tc.name: NativeNodeTest069
4921  * @tc.desc: Test lengthMetricUnit function.
4922  * @tc.type: FUNC
4923  */
HWTEST_F(NativeNodeTest, NativeNodeTest069, TestSize.Level1)4924 HWTEST_F(NativeNodeTest, NativeNodeTest069, TestSize.Level1)
4925 {
4926     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
4927         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
4928     auto node = nodeAPI->createNode(ARKUI_NODE_STACK);
4929     EXPECT_EQ(nodeAPI->setLengthMetricUnit(nullptr, ARKUI_LENGTH_METRIC_UNIT_PX), ARKUI_ERROR_CODE_PARAM_INVALID);
4930     EXPECT_EQ(nodeAPI->setLengthMetricUnit(node, static_cast<ArkUI_LengthMetricUnit>(-2)),
4931         ARKUI_ERROR_CODE_PARAM_INVALID);
4932     EXPECT_EQ(nodeAPI->setLengthMetricUnit(node, ARKUI_LENGTH_METRIC_UNIT_PX), ARKUI_ERROR_CODE_NO_ERROR);
4933     ArkUI_NumberValue value[] = {{.f32 = 10.0f}, {.f32 = 10.0f}};
4934     ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue)};
4935     nodeAPI->setAttribute(node, NODE_WIDTH, &item);
4936     nodeAPI->setLengthMetricUnit(node, ARKUI_LENGTH_METRIC_UNIT_FP);
4937     EXPECT_EQ(nodeAPI->setAttribute(node, NODE_SCROLL_BY, &item), ARKUI_ERROR_CODE_PARAM_INVALID);
4938     nodeAPI->disposeNode(node);
4939 }
4940 
4941 /**
4942  * @tc.name: NativeNodeTest070
4943  * @tc.desc: Test convertEvent function.
4944  * @tc.type: FUNC
4945  */
HWTEST_F(NativeNodeTest, NativeNodeTest070, TestSize.Level1)4946 HWTEST_F(NativeNodeTest, NativeNodeTest070, TestSize.Level1)
4947 {
4948     ArkUINodeEvent origin;
4949     ArkUI_NodeEvent event;
4950     ArkUI_CompatibleNodeEvent compatibleEvent;
4951     const std::string str = "test";
4952     origin.kind = ArkUIEventCategory::COMPONENT_ASYNC_EVENT;
4953     origin.componentAsyncEvent.subKind = ArkUIEventSubKind::ON_VISIBLE_AREA_CHANGE;
4954     origin.componentAsyncEvent.data[0].i32 = 0;
4955     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertEvent(&origin, &event), true);
4956     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertEvent(&origin, &compatibleEvent), true);
4957     origin.kind = ArkUIEventCategory::TEXT_INPUT;
4958     origin.textInputEvent.subKind = ArkUIEventSubKind::ON_TEXT_INPUT_CHANGE;
4959     origin.textInputEvent.nativeStringPtr = reinterpret_cast<intptr_t>(str.c_str());
4960     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertEvent(&origin, &event), true);
4961     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertEvent(&origin, &compatibleEvent), true);
4962     origin.kind = ArkUIEventCategory::TOUCH_EVENT;
4963     origin.touchEvent.subKind = ArkUIEventSubKind::ON_TOUCH;
4964     origin.touchEvent.sourceType = 2;
4965     origin.touchEvent.action = 0;
4966     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertEvent(&origin, &event), true);
4967     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertEvent(&origin, &compatibleEvent), true);
4968     origin.touchEvent.sourceType = 0;
4969     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertEvent(&origin, &compatibleEvent), true);
4970     origin.touchEvent.action = 1;
4971     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertEvent(&origin, &compatibleEvent), true);
4972     origin.touchEvent.action = 2;
4973     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertEvent(&origin, &compatibleEvent), true);
4974     origin.touchEvent.action = 3;
4975     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertEvent(&origin, &compatibleEvent), true);
4976     origin.touchEvent.action = 4;
4977     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertEvent(&origin, &compatibleEvent), true);
4978 
4979     origin.kind = ArkUIEventCategory::MOUSE_INPUT_EVENT;
4980     origin.mouseEvent.subKind = ArkUIEventSubKind::ON_MOUSE;
4981     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertEvent(&origin, &event), true);
4982     origin.kind = ArkUIEventCategory::MIXED_EVENT;
4983     origin.mouseEvent.subKind = ArkUIEventSubKind::ON_TEXT_AREA_WILL_INSERT;
4984     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertEvent(&origin, &event), true);
4985     origin.kind = ArkUIEventCategory::INVALID;
4986     origin.mouseEvent.subKind = ArkUIEventSubKind::ON_TEXT_AREA_WILL_INSERT;
4987     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertEvent(&origin, &event), false);
4988     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertEvent(&origin, &compatibleEvent), false);
4989 }
4990 
4991 /**
4992  * @tc.name: NativeNodeTest071
4993  * @tc.desc: Test ConvertToCTouch function.
4994  * @tc.type: FUNC
4995  */
HWTEST_F(NativeNodeTest, NativeNodeTest071, TestSize.Level1)4996 HWTEST_F(NativeNodeTest, NativeNodeTest071, TestSize.Level1)
4997 {
4998     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertToCTouchActionType(0), 1);
4999     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertToCTouchActionType(1), 3);
5000     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertToCTouchActionType(2), 2);
5001     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertToCTouchActionType(3), 0);
5002     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertToCTouchActionType(-1), -1);
5003 
5004     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertToCInputEventToolType(1), 1);
5005     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertToCInputEventToolType(2), 2);
5006     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertToCInputEventToolType(7), 3);
5007     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertToCInputEventToolType(9), 4);
5008     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertToCInputEventToolType(0), 0);
5009 
5010     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertToCMouseActionType(1), 1);
5011     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertToCMouseActionType(2), 2);
5012     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertToCMouseActionType(3), 3);
5013     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertToCMouseActionType(0), 0);
5014 
5015     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertToCMouseEventButtonType(1), 1);
5016     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertToCMouseEventButtonType(2), 2);
5017     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertToCMouseEventButtonType(4), 3);
5018     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertToCMouseEventButtonType(8), 4);
5019     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertToCMouseEventButtonType(16), 5);
5020     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertToCMouseEventButtonType(-1), 0);
5021 }
5022 
5023 /**
5024  * @tc.name: NativeNodeTest072
5025  * @tc.desc: Test convertEventResult function.
5026  * @tc.type: FUNC
5027  */
HWTEST_F(NativeNodeTest, NativeNodeTest072, TestSize.Level1)5028 HWTEST_F(NativeNodeTest, NativeNodeTest072, TestSize.Level1)
5029 {
5030     ArkUINodeEvent event;
5031     ArkUI_CompatibleNodeEvent origin;
5032     origin.kind = ArkUI_NodeEventType::NODE_TOUCH_EVENT;
5033     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertEventResult(&origin, &event), true);
5034     origin.kind = ArkUI_NodeEventType::NODE_ON_TOUCH_INTERCEPT;
5035     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertEventResult(&origin, &event), true);
5036     origin.kind = ArkUI_NodeEventType::NODE_TEXT_INPUT_ON_CHANGE;
5037     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertEventResult(&origin, &event), true);
5038     origin.kind = ArkUI_NodeEventType::NODE_TEXT_INPUT_ON_CUT;
5039     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertEventResult(&origin, &event), true);
5040     origin.kind = ArkUI_NodeEventType::NODE_TEXT_INPUT_ON_PASTE;
5041     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertEventResult(&origin, &event), true);
5042     origin.kind = ArkUI_NodeEventType::NODE_TEXT_AREA_ON_CHANGE;
5043     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertEventResult(&origin, &event), true);
5044     origin.kind = ArkUI_NodeEventType::NODE_TEXT_AREA_ON_PASTE;
5045     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertEventResult(&origin, &event), true);
5046     origin.kind = ArkUI_NodeEventType::NODE_EVENT_ON_APPEAR;
5047     EXPECT_EQ(OHOS::Ace::NodeModel::ConvertEventResult(&origin, &event), true);
5048 }
5049 
5050 /**
5051  * @tc.name: NativeNodeTest073
5052  * @tc.desc: Test OH_ArkUI_NodeEvent_GetInputEvent function.
5053  * @tc.type: FUNC
5054  */
HWTEST_F(NativeNodeTest, NativeNodeTest073, TestSize.Level1)5055 HWTEST_F(NativeNodeTest, NativeNodeTest073, TestSize.Level1)
5056 {
5057     ArkUI_NodeEvent event = { 1, 0 };
5058     event.origin = nullptr;
5059     EXPECT_EQ(OH_ArkUI_NodeEvent_GetInputEvent(nullptr), nullptr);
5060     EXPECT_EQ(OH_ArkUI_NodeEvent_GetInputEvent(nullptr), nullptr);
5061     event.category = 0;
5062     EXPECT_EQ(OH_ArkUI_NodeEvent_GetInputEvent(&event), nullptr);
5063 }
5064 
5065 /**
5066  * @tc.name: NativeNodeTest074
5067  * @tc.desc: Test OH_ArkUI_NodeEvent_GetNodeComponentEvent function.
5068  * @tc.type: FUNC
5069  */
HWTEST_F(NativeNodeTest, NativeNodeTest074, TestSize.Level1)5070 HWTEST_F(NativeNodeTest, NativeNodeTest074, TestSize.Level1)
5071 {
5072     ArkUI_NodeEvent event = { 0, 0 };
5073     event.origin = nullptr;
5074     EXPECT_EQ(OH_ArkUI_NodeEvent_GetNodeComponentEvent(nullptr), nullptr);
5075     EXPECT_EQ(OH_ArkUI_NodeEvent_GetNodeComponentEvent(&event), nullptr);
5076     event.category = 1;
5077     EXPECT_EQ(OH_ArkUI_NodeEvent_GetNodeComponentEvent(&event), nullptr);
5078     ArkUINodeEvent origin = { 0, 0, 0};
5079     origin.componentAsyncEvent.subKind = ArkUIEventSubKind::ON_VISIBLE_AREA_CHANGE;
5080     origin.componentAsyncEvent.data[0].i32 = 0;
5081     event.origin = &origin;
5082     EXPECT_NE(OH_ArkUI_NodeEvent_GetNodeComponentEvent(&event), nullptr);
5083 }
5084 
5085 /**
5086  * @tc.name: NativeNodeTest075
5087  * @tc.desc: Test OH_ArkUI_NodeEvent_GetStringAsyncEvent function.
5088  * @tc.type: FUNC
5089  */
HWTEST_F(NativeNodeTest, NativeNodeTest075, TestSize.Level1)5090 HWTEST_F(NativeNodeTest, NativeNodeTest075, TestSize.Level1)
5091 {
5092     ArkUI_NodeEvent event = { 0, 0 };
5093     event.origin = nullptr;
5094     const std::string str = "test";
5095     EXPECT_EQ(OH_ArkUI_NodeEvent_GetStringAsyncEvent(nullptr), nullptr);
5096     EXPECT_EQ(OH_ArkUI_NodeEvent_GetStringAsyncEvent(&event), nullptr);
5097     event.category = 2;
5098     EXPECT_EQ(OH_ArkUI_NodeEvent_GetStringAsyncEvent(&event), nullptr);
5099     ArkUINodeEvent origin = { 0, 0, 0};
5100     origin.textInputEvent.subKind = ArkUIEventSubKind::ON_TEXT_INPUT_CHANGE;
5101     origin.textInputEvent.nativeStringPtr = reinterpret_cast<intptr_t>(str.c_str());
5102     event.origin = &origin;
5103     EXPECT_NE(OH_ArkUI_NodeEvent_GetStringAsyncEvent(&event), nullptr);
5104 }
5105 
5106 /**
5107  * @tc.name: NativeNodeTest076
5108  * @tc.desc: Test OH_ArkUI_NodeEvent_GetUserData function.
5109  * @tc.type: FUNC
5110  */
HWTEST_F(NativeNodeTest, NativeNodeTest076, TestSize.Level1)5111 HWTEST_F(NativeNodeTest, NativeNodeTest076, TestSize.Level1)
5112 {
5113     ArkUI_NodeEvent event = { 0, 0 };
5114     event.userData = nullptr;
5115     EXPECT_EQ(OH_ArkUI_NodeEvent_GetUserData(nullptr), nullptr);
5116     EXPECT_EQ(OH_ArkUI_NodeEvent_GetUserData(&event), nullptr);
5117 }
5118 
5119 /**
5120  * @tc.name: NativeNodeTest077
5121  * @tc.desc: Test OH_ArkUI_NodeEvent_GetNumberValue function.
5122  * @tc.type: FUNC
5123  */
HWTEST_F(NativeNodeTest, NativeNodeTest077, TestSize.Level1)5124 HWTEST_F(NativeNodeTest, NativeNodeTest077, TestSize.Level1)
5125 {
5126     ArkUI_NodeEvent event = { 0, 0 };
5127     event.origin = nullptr;
5128     int32_t index = 0;
5129     ArkUI_NumberValue value[] = {{.f32 = 10.0f}};
5130     EXPECT_EQ(OH_ArkUI_NodeEvent_GetNumberValue(nullptr, index, value), 106108);
5131     EXPECT_EQ(OH_ArkUI_NodeEvent_GetNumberValue(&event, index, value), 106108);
5132     event.category = 3;
5133     EXPECT_EQ(OH_ArkUI_NodeEvent_GetNumberValue(&event, index, value), 106108);
5134     ArkUINodeEvent mixEvent;
5135     mixEvent.kind = ArkUIEventCategory::MIXED_EVENT;
5136     mixEvent.extraParam = reinterpret_cast<intptr_t>(nullptr);
5137     mixEvent.mixedEvent.subKind = ArkUIEventSubKind::ON_TEXT_AREA_WILL_INSERT;
5138     mixEvent.mixedEvent.numberData[0].f32 = 0.0f;
5139     mixEvent.mixedEvent.numberDataLength = 1;
5140     event.origin = &mixEvent;
5141     index = 2;
5142     EXPECT_EQ(OH_ArkUI_NodeEvent_GetNumberValue(&event, index, value), 106107);
5143     index = -1;
5144     EXPECT_EQ(OH_ArkUI_NodeEvent_GetNumberValue(&event, index, value), 106107);
5145     index = 0;
5146     EXPECT_EQ(OH_ArkUI_NodeEvent_GetNumberValue(&event, index, value), ARKUI_ERROR_CODE_NO_ERROR);
5147 }
5148 
5149 /**
5150  * @tc.name: NativeNodeTest078
5151  * @tc.desc: Test OH_ArkUI_NodeEvent_GetStringValue function.
5152  * @tc.type: FUNC
5153  */
HWTEST_F(NativeNodeTest, NativeNodeTest078, TestSize.Level1)5154 HWTEST_F(NativeNodeTest, NativeNodeTest078, TestSize.Level1)
5155 {
5156     ArkUI_NodeEvent event = { 0, 0 };
5157     event.origin = nullptr;
5158     int32_t index = 0;
5159     int32_t size = 0;
5160     char* value[size];
5161     const std::string str1 = "";
5162     const std::string str2 = "test";
5163     EXPECT_EQ(OH_ArkUI_NodeEvent_GetStringValue(nullptr, index, value, &size), 106108);
5164     EXPECT_EQ(OH_ArkUI_NodeEvent_GetStringValue(&event, index, value, &size), 106108);
5165     event.category = 3;
5166     EXPECT_EQ(OH_ArkUI_NodeEvent_GetStringValue(&event, index, value, &size), 106108);
5167     ArkUINodeEvent mixEvent;
5168     mixEvent.kind = ArkUIEventCategory::MIXED_EVENT;
5169     mixEvent.extraParam = reinterpret_cast<intptr_t>(nullptr);
5170     mixEvent.mixedEvent.subKind = ArkUIEventSubKind::ON_TEXT_AREA_WILL_INSERT;
5171     mixEvent.mixedEvent.stringPtrData[0] = reinterpret_cast<intptr_t>(str1.c_str());
5172     mixEvent.mixedEvent.stringPtrDataLength = 1;
5173     event.origin = &mixEvent;
5174     index = 2;
5175     EXPECT_EQ(OH_ArkUI_NodeEvent_GetStringValue(&event, index, value, &size), 106107);
5176     index = 0;
5177     EXPECT_EQ(OH_ArkUI_NodeEvent_GetStringValue(&event, index, value, &size), 106108);
5178     mixEvent.mixedEvent.stringPtrData[0] = reinterpret_cast<intptr_t>(str2.c_str());
5179     EXPECT_EQ(OH_ArkUI_NodeEvent_GetStringValue(&event, index, value, &size), 106108);
5180 }
5181 
5182 /**
5183  * @tc.name: NativeNodeTest079
5184  * @tc.desc: Test OH_ArkUI_NodeEvent_SetReturnNumberValue function.
5185  * @tc.type: FUNC
5186  */
HWTEST_F(NativeNodeTest, NativeNodeTest079, TestSize.Level1)5187 HWTEST_F(NativeNodeTest, NativeNodeTest079, TestSize.Level1)
5188 {
5189     ArkUI_NodeEvent event = { 0, 0 };
5190     event.origin = nullptr;
5191     int32_t size = 1;
5192     ArkUI_NumberValue value[] = {{.i32 = 10}};
5193     EXPECT_EQ(OH_ArkUI_NodeEvent_SetReturnNumberValue(nullptr, value, size), 106108);
5194     EXPECT_EQ(OH_ArkUI_NodeEvent_SetReturnNumberValue(&event, value, size), 106108);
5195     event.category = 3;
5196     EXPECT_EQ(OH_ArkUI_NodeEvent_SetReturnNumberValue(&event, value, size), 106108);
5197     ArkUINodeEvent mixEvent;
5198     mixEvent.kind = ArkUIEventCategory::MIXED_EVENT;
5199     mixEvent.extraParam = reinterpret_cast<intptr_t>(nullptr);
5200     mixEvent.mixedEvent.subKind = ArkUIEventSubKind::ON_TEXT_AREA_WILL_INSERT;
5201     event.origin = &mixEvent;
5202     EXPECT_EQ(OH_ArkUI_NodeEvent_SetReturnNumberValue(&event, value, size), ARKUI_ERROR_CODE_NO_ERROR);
5203 }
5204 
5205 /**
5206  * @tc.name: NativeNodeTest080
5207  * @tc.desc: Test customSpanNode function.
5208  * @tc.type: FUNC
5209  */
HWTEST_F(NativeNodeTest, NativeNodeTest080, TestSize.Level1)5210 HWTEST_F(NativeNodeTest, NativeNodeTest080, TestSize.Level1)
5211 {
5212     auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>(
5213         OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1"));
5214     auto rootNode = new ArkUI_Node({ARKUI_NODE_CUSTOM_SPAN, nullptr});
5215 
5216     EXPECT_EQ(nodeAPI->registerNodeCustomEvent(
5217         rootNode, ARKUI_NODE_CUSTOM_EVENT_ON_MEASURE, 0, nullptr), ARKUI_ERROR_CODE_NO_ERROR);
5218     EXPECT_EQ(nodeAPI->registerNodeCustomEvent(
5219         rootNode, ARKUI_NODE_CUSTOM_EVENT_ON_DRAW, 1, nullptr), ARKUI_ERROR_CODE_NO_ERROR);
5220     nodeAPI->unregisterNodeCustomEvent(rootNode, ARKUI_NODE_CUSTOM_EVENT_ON_MEASURE);
5221     nodeAPI->unregisterNodeCustomEvent(rootNode, ARKUI_NODE_CUSTOM_EVENT_ON_DRAW);
5222     nodeAPI->disposeNode(rootNode);
5223 }
5224 } // namespace OHOS::Ace