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