1 /* 2 * Copyright (c) 2025 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #include <cstddef> 17 #include <cstdint> 18 #include "gtest/gtest.h" 19 #define private public 20 #define protected public 21 #include "native_interface.h" 22 #include "native_node.h" 23 #include "native_render.h" 24 #include "native_type.h" 25 #include "interfaces/native/node/node_extened.h" 26 #include "interfaces/native/node/node_model.h" 27 #include "interfaces/native/node/render_node.h" 28 #include "interfaces/native/node/styled_string.h" 29 #include "test/mock/base/mock_task_executor.h" 30 #include "test/mock/core/common/mock_container.h" 31 #include "test/mock/core/common/mock_theme_manager.h" 32 #include "test/mock/core/pipeline/mock_pipeline_context.h" 33 #include "frameworks/base/error/error_code.h" 34 #include "frameworks/core/components_ng/base/ui_node.h" 35 36 using namespace testing; 37 using namespace testing::ext; 38 namespace OHOS::Ace { 39 class NativeRenderNodePropertyTest : public testing::Test { 40 public: SetUpTestSuite()41 static void SetUpTestSuite() 42 { 43 NG::MockPipelineContext::SetUp(); 44 MockContainer::SetUp(); 45 MockContainer::Current()->pipelineContext_ = NG::MockPipelineContext::GetCurrent(); 46 MockContainer::Current()->taskExecutor_ = AceType::MakeRefPtr<MockTaskExecutor>(); 47 MockContainer::Current()->pipelineContext_->taskExecutor_ = MockContainer::Current()->taskExecutor_; 48 auto themeManager = AceType::MakeRefPtr<MockThemeManager>(); 49 PipelineBase::GetCurrentContext()->SetThemeManager(themeManager); 50 } TearDownTestSuite()51 static void TearDownTestSuite() 52 { 53 NG::MockPipelineContext::TearDown(); 54 MockContainer::TearDown(); 55 } SetUp()56 void SetUp() {} TearDown()57 void TearDown() {} 58 }; 59 60 /** 61 * @tc.name: NativeRenderNodePropertyTest001 62 * @tc.desc: Test renderNode backgroundColor. 63 * @tc.type: FUNC 64 */ 65 HWTEST_F(NativeRenderNodePropertyTest, NativeRenderNodePropertyTest001, TestSize.Level1) 66 { 67 auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>( 68 OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1")); 69 auto rootCustomNode = nodeAPI->createNode(ARKUI_NODE_CUSTOM); 70 ASSERT_NE(rootCustomNode, nullptr); 71 auto rootRenderNode = OH_ArkUI_RenderNodeUtils_CreateNode(); 72 ASSERT_NE(rootRenderNode, nullptr); 73 74 uint32_t backgroundColor = 0; 75 OH_ArkUI_RenderNodeUtils_SetBackgroundColor(rootRenderNode, 80000000); 76 OH_ArkUI_RenderNodeUtils_GetBackgroundColor(rootRenderNode, &backgroundColor); 77 ASSERT_EQ(backgroundColor, 79803706); 78 } 79 80 /** 81 * @tc.name: NativeRenderNodePropertyTest002 82 * @tc.desc: Test renderNode ClipToFrame. 83 * @tc.type: FUNC 84 */ 85 HWTEST_F(NativeRenderNodePropertyTest, NativeRenderNodePropertyTest002, TestSize.Level1) 86 { 87 auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>( 88 OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1")); 89 auto rootCustomNode = nodeAPI->createNode(ARKUI_NODE_CUSTOM); 90 ASSERT_NE(rootCustomNode, nullptr); 91 auto rootRenderNode = OH_ArkUI_RenderNodeUtils_CreateNode(); 92 ASSERT_NE(rootRenderNode, nullptr); 93 94 int32_t clipToFrameResult = true; 95 OH_ArkUI_RenderNodeUtils_SetClipToFrame(rootRenderNode, true); 96 OH_ArkUI_RenderNodeUtils_GetClipToFrame(rootRenderNode, &clipToFrameResult); 97 ASSERT_TRUE(clipToFrameResult); 98 } 99 100 /** 101 * @tc.name: NativeRenderNodePropertyTest003 102 * @tc.desc: Test renderNode ClipToBounds. 103 * @tc.type: FUNC 104 */ 105 HWTEST_F(NativeRenderNodePropertyTest, NativeRenderNodePropertyTest003, TestSize.Level1) 106 { 107 auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>( 108 OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1")); 109 auto rootCustomNode = nodeAPI->createNode(ARKUI_NODE_CUSTOM); 110 ASSERT_NE(rootCustomNode, nullptr); 111 auto rootRenderNode = OH_ArkUI_RenderNodeUtils_CreateNode(); 112 ASSERT_NE(rootRenderNode, nullptr); 113 114 int32_t clipToBounds = true; 115 OH_ArkUI_RenderNodeUtils_SetClipToBounds(rootRenderNode, 1); 116 OH_ArkUI_RenderNodeUtils_GetClipToBounds(rootRenderNode, &clipToBounds); 117 ASSERT_TRUE(clipToBounds); 118 } 119 120 /** 121 * @tc.name: NativeRenderNodePropertyTest004 122 * @tc.desc: Test renderNode opacity. 123 * @tc.type: FUNC 124 */ 125 HWTEST_F(NativeRenderNodePropertyTest, NativeRenderNodePropertyTest004, TestSize.Level1) 126 { 127 auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>( 128 OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1")); 129 auto rootCustomNode = nodeAPI->createNode(ARKUI_NODE_CUSTOM); 130 ASSERT_NE(rootCustomNode, nullptr); 131 auto rootRenderNode = OH_ArkUI_RenderNodeUtils_CreateNode(); 132 ASSERT_NE(rootRenderNode, nullptr); 133 134 float opacity = 0; 135 OH_ArkUI_RenderNodeUtils_SetOpacity(rootRenderNode, 0.5f); 136 OH_ArkUI_RenderNodeUtils_GetOpacity(rootRenderNode, &opacity); 137 ASSERT_EQ(opacity, 0.5f); 138 } 139 140 /** 141 * @tc.name: NativeRenderNodePropertyTest005 142 * @tc.desc: Test renderNode size. 143 * @tc.type: FUNC 144 */ 145 HWTEST_F(NativeRenderNodePropertyTest, NativeRenderNodePropertyTest005, TestSize.Level1) 146 { 147 auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>( 148 OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1")); 149 auto rootCustomNode = nodeAPI->createNode(ARKUI_NODE_CUSTOM); 150 ASSERT_NE(rootCustomNode, nullptr); 151 auto rootRenderNode = OH_ArkUI_RenderNodeUtils_CreateNode(); 152 ASSERT_NE(rootRenderNode, nullptr); 153 154 int32_t getSizeWidth = 0; 155 int32_t getSizeHeight = 0; 156 OH_ArkUI_RenderNodeUtils_SetSize(rootRenderNode, 300, 400); 157 OH_ArkUI_RenderNodeUtils_GetSize(rootRenderNode, &getSizeWidth, &getSizeHeight); 158 ASSERT_EQ(getSizeWidth, 300); 159 ASSERT_EQ(getSizeHeight, 400); 160 } 161 162 /** 163 * @tc.name: NativeRenderNodePropertyTest006 164 * @tc.desc: Test renderNode position. 165 * @tc.type: FUNC 166 */ 167 HWTEST_F(NativeRenderNodePropertyTest, NativeRenderNodePropertyTest006, TestSize.Level1) 168 { 169 auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>( 170 OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1")); 171 auto rootCustomNode = nodeAPI->createNode(ARKUI_NODE_CUSTOM); 172 ASSERT_NE(rootCustomNode, nullptr); 173 auto rootRenderNode = OH_ArkUI_RenderNodeUtils_CreateNode(); 174 ASSERT_NE(rootRenderNode, nullptr); 175 176 int32_t setPositionX = 0; 177 int32_t setPositionY = 0; 178 OH_ArkUI_RenderNodeUtils_SetPosition(rootRenderNode, 200, 1500); 179 OH_ArkUI_RenderNodeUtils_GetPosition(rootRenderNode, &setPositionX, &setPositionY); 180 ASSERT_EQ(setPositionX, 200); 181 ASSERT_EQ(setPositionY, 1500); 182 } 183 184 /** 185 * @tc.name: NativeRenderNodePropertyTest007 186 * @tc.desc: Test renderNode pivot. 187 * @tc.type: FUNC 188 */ 189 HWTEST_F(NativeRenderNodePropertyTest, NativeRenderNodePropertyTest007, TestSize.Level1) 190 { 191 auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>( 192 OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1")); 193 auto rootCustomNode = nodeAPI->createNode(ARKUI_NODE_CUSTOM); 194 ASSERT_NE(rootCustomNode, nullptr); 195 auto rootRenderNode = OH_ArkUI_RenderNodeUtils_CreateNode(); 196 ASSERT_NE(rootRenderNode, nullptr); 197 198 float setPivotX = 0; 199 float setPivotY = 0; 200 OH_ArkUI_RenderNodeUtils_SetPivot(rootRenderNode, 5655, 232); 201 OH_ArkUI_RenderNodeUtils_GetPivot(rootRenderNode, &setPivotX, &setPivotY); 202 ASSERT_EQ(setPivotX, 5655); 203 ASSERT_EQ(setPivotY, 232); 204 } 205 206 /** 207 * @tc.name: NativeRenderNodePropertyTest008 208 * @tc.desc: Test renderNode scale. 209 * @tc.type: FUNC 210 */ 211 HWTEST_F(NativeRenderNodePropertyTest, NativeRenderNodePropertyTest008, TestSize.Level1) 212 { 213 auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>( 214 OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1")); 215 auto rootCustomNode = nodeAPI->createNode(ARKUI_NODE_CUSTOM); 216 ASSERT_NE(rootCustomNode, nullptr); 217 auto rootRenderNode = OH_ArkUI_RenderNodeUtils_CreateNode(); 218 ASSERT_NE(rootRenderNode, nullptr); 219 220 float setScaleX = 0; 221 float setScaleY = 0; 222 OH_ArkUI_RenderNodeUtils_SetScale(rootRenderNode, 36, 39); 223 OH_ArkUI_RenderNodeUtils_GetScale(rootRenderNode, &setScaleX, &setScaleY); 224 ASSERT_EQ(setScaleX, 36); 225 ASSERT_EQ(setScaleY, 39); 226 } 227 228 /** 229 * @tc.name: NativeRenderNodePropertyTest009 230 * @tc.desc: Test renderNode translation. 231 * @tc.type: FUNC 232 */ 233 HWTEST_F(NativeRenderNodePropertyTest, NativeRenderNodePropertyTest009, TestSize.Level1) 234 { 235 auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>( 236 OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1")); 237 auto rootCustomNode = nodeAPI->createNode(ARKUI_NODE_CUSTOM); 238 ASSERT_NE(rootCustomNode, nullptr); 239 auto rootRenderNode = OH_ArkUI_RenderNodeUtils_CreateNode(); 240 ASSERT_NE(rootRenderNode, nullptr); 241 242 float setTranslationX = 0; 243 float setTranslationY = 0; 244 OH_ArkUI_RenderNodeUtils_SetTranslation(rootRenderNode, 33, 44); 245 OH_ArkUI_RenderNodeUtils_GetTranslation(rootRenderNode, &setTranslationX, &setTranslationY); 246 ASSERT_EQ(setTranslationX, 33); 247 ASSERT_EQ(setTranslationY, 44); 248 } 249 250 /** 251 * @tc.name: NativeRenderNodePropertyTest010 252 * @tc.desc: Test renderNode rotation. 253 * @tc.type: FUNC 254 */ 255 HWTEST_F(NativeRenderNodePropertyTest, NativeRenderNodePropertyTest010, TestSize.Level1) 256 { 257 auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>( 258 OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1")); 259 auto rootCustomNode = nodeAPI->createNode(ARKUI_NODE_CUSTOM); 260 ASSERT_NE(rootCustomNode, nullptr); 261 auto rootRenderNode = OH_ArkUI_RenderNodeUtils_CreateNode(); 262 ASSERT_NE(rootRenderNode, nullptr); 263 264 float setRotationX = 0; 265 float setRotationY = 0; 266 float setRotationZ = 0; 267 OH_ArkUI_RenderNodeUtils_SetRotation(rootRenderNode, 414, 55, 12); 268 OH_ArkUI_RenderNodeUtils_GetRotation(rootRenderNode, &setRotationX, &setRotationY, &setRotationZ); 269 ASSERT_EQ(setRotationX, 414); 270 ASSERT_EQ(setRotationY, 55); 271 ASSERT_EQ(setRotationZ, 12); 272 } 273 274 /** 275 * @tc.name: NativeRenderNodePropertyTest011 276 * @tc.desc: Test renderNode shadowColor. 277 * @tc.type: FUNC 278 */ 279 HWTEST_F(NativeRenderNodePropertyTest, NativeRenderNodePropertyTest011, TestSize.Level1) 280 { 281 auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>( 282 OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1")); 283 auto rootCustomNode = nodeAPI->createNode(ARKUI_NODE_CUSTOM); 284 ASSERT_NE(rootCustomNode, nullptr); 285 auto rootRenderNode = OH_ArkUI_RenderNodeUtils_CreateNode(); 286 ASSERT_NE(rootRenderNode, nullptr); 287 288 uint32_t shadowColor = 0; 289 OH_ArkUI_RenderNodeUtils_SetShadowColor(rootRenderNode, 80000000); 290 OH_ArkUI_RenderNodeUtils_GetShadowColor(rootRenderNode, &shadowColor); 291 ASSERT_EQ(shadowColor, 80000000); 292 } 293 294 /** 295 * @tc.name: NativeRenderNodePropertyTest012 296 * @tc.desc: Test renderNode shadowOffset. 297 * @tc.type: FUNC 298 */ 299 HWTEST_F(NativeRenderNodePropertyTest, NativeRenderNodePropertyTest012, TestSize.Level1) 300 { 301 auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>( 302 OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1")); 303 auto rootCustomNode = nodeAPI->createNode(ARKUI_NODE_CUSTOM); 304 ASSERT_NE(rootCustomNode, nullptr); 305 auto rootRenderNode = OH_ArkUI_RenderNodeUtils_CreateNode(); 306 ASSERT_NE(rootRenderNode, nullptr); 307 308 int32_t shadowOffsetX = 0; 309 int32_t shadowOffsetY = 0; 310 OH_ArkUI_RenderNodeUtils_SetShadowOffset(rootRenderNode, 27, 56); 311 OH_ArkUI_RenderNodeUtils_GetShadowOffset(rootRenderNode, &shadowOffsetX, &shadowOffsetY); 312 ASSERT_EQ(shadowOffsetX, 27); 313 ASSERT_EQ(shadowOffsetY, 56); 314 } 315 316 /** 317 * @tc.name: NativeRenderNodePropertyTest013 318 * @tc.desc: Test renderNode shadowAlpha. 319 * @tc.type: FUNC 320 */ 321 HWTEST_F(NativeRenderNodePropertyTest, NativeRenderNodePropertyTest013, TestSize.Level1) 322 { 323 auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>( 324 OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1")); 325 auto rootCustomNode = nodeAPI->createNode(ARKUI_NODE_CUSTOM); 326 ASSERT_NE(rootCustomNode, nullptr); 327 auto rootRenderNode = OH_ArkUI_RenderNodeUtils_CreateNode(); 328 ASSERT_NE(rootRenderNode, nullptr); 329 330 float alpha = 0; 331 OH_ArkUI_RenderNodeUtils_SetShadowAlpha(rootRenderNode, 0.5f); 332 OH_ArkUI_RenderNodeUtils_GetShadowAlpha(rootRenderNode, &alpha); 333 ASSERT_LE(alpha, 0.5f); 334 } 335 336 /** 337 * @tc.name: NativeRenderNodePropertyTest014 338 * @tc.desc: Test renderNode shadowElevation. 339 * @tc.type: FUNC 340 */ 341 HWTEST_F(NativeRenderNodePropertyTest, NativeRenderNodePropertyTest014, TestSize.Level1) 342 { 343 auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>( 344 OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1")); 345 auto rootCustomNode = nodeAPI->createNode(ARKUI_NODE_CUSTOM); 346 ASSERT_NE(rootCustomNode, nullptr); 347 auto rootRenderNode = OH_ArkUI_RenderNodeUtils_CreateNode(); 348 ASSERT_NE(rootRenderNode, nullptr); 349 350 float elevation = 0; 351 OH_ArkUI_RenderNodeUtils_SetShadowElevation(rootRenderNode, 67556); 352 OH_ArkUI_RenderNodeUtils_GetShadowElevation(rootRenderNode, &elevation); 353 ASSERT_EQ(elevation, 67556); 354 } 355 356 /** 357 * @tc.name: NativeRenderNodePropertyTest015 358 * @tc.desc: Test renderNode shadowRadius. 359 * @tc.type: FUNC 360 */ 361 HWTEST_F(NativeRenderNodePropertyTest, NativeRenderNodePropertyTest015, TestSize.Level1) 362 { 363 auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>( 364 OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1")); 365 auto rootCustomNode = nodeAPI->createNode(ARKUI_NODE_CUSTOM); 366 ASSERT_NE(rootCustomNode, nullptr); 367 auto rootRenderNode = OH_ArkUI_RenderNodeUtils_CreateNode(); 368 ASSERT_NE(rootRenderNode, nullptr); 369 370 float radius = 0; 371 OH_ArkUI_RenderNodeUtils_SetShadowRadius(rootRenderNode, 235553); 372 OH_ArkUI_RenderNodeUtils_GetShadowRadius(rootRenderNode, &radius); 373 ASSERT_EQ(radius, 235553); 374 } 375 376 /** 377 * @tc.name: NativeRenderNodePropertyTest016 378 * @tc.desc: Test renderNode transform. 379 * @tc.type: FUNC 380 */ 381 HWTEST_F(NativeRenderNodePropertyTest, NativeRenderNodePropertyTest016, TestSize.Level1) 382 { 383 auto nodeAPI = reinterpret_cast<ArkUI_NativeNodeAPI_1*>( 384 OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_NODE, "ArkUI_NativeNodeAPI_1")); 385 auto rootCustomNode = nodeAPI->createNode(ARKUI_NODE_CUSTOM); 386 ASSERT_NE(rootCustomNode, nullptr); 387 auto rootRenderNode = OH_ArkUI_RenderNodeUtils_CreateNode(); 388 ASSERT_NE(rootRenderNode, nullptr); 389 390 float matrix[] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }; 391 auto result = OH_ArkUI_RenderNodeUtils_SetTransform(rootRenderNode, matrix); 392 ASSERT_EQ(result, ERROR_CODE_NO_ERROR); 393 } 394 } // namespace OHOS::Ace