1 /* 2 * Copyright (c) 2024 iSoftStone Information Technology (Group) 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 <optional> 17 18 #include "gtest/gtest.h" 19 20 #define protected public 21 #define private public 22 #include "test/mock/core/pipeline/mock_pipeline_context.h" 23 #include "test/mock/core/render/mock_render_context.h" 24 25 #include "base/geometry/dimension.h" 26 #include "core/components/common/layout/constants.h" 27 #include "core/components_ng/layout/layout_property.h" 28 29 #undef private 30 #undef protected 31 32 using namespace testing; 33 using namespace testing::ext; 34 35 namespace OHOS::Ace::NG { 36 namespace { 37 } // namespace 38 39 class LayoutPropertyTestNgTwo : public testing::Test { 40 public: SetUpTestSuite()41 static void SetUpTestSuite() 42 { 43 MockPipelineContext::SetUp(); 44 } TearDownTestSuite()45 static void TearDownTestSuite() 46 { 47 MockPipelineContext::TearDown(); 48 } 49 }; 50 51 /** 52 * @tc.name: CheckLocalizedBorderImageOutset001 53 * @tc.desc: Test CheckLocalizedBorderImageOutset when borderImageStart_ has value 54 * @tc.type: FUNC 55 */ 56 HWTEST_F(LayoutPropertyTestNgTwo, CheckLocalizedBorderImageOutset001, TestSize.Level1) 57 { 58 auto layoutProperty = AceType::MakeRefPtr<LayoutProperty>(); 59 auto frameNodeHost = FrameNode::CreateFrameNode("host", 1, AceType::MakeRefPtr<Pattern>(), true); 60 layoutProperty->SetHost(frameNodeHost); 61 62 auto renderContext = frameNodeHost->GetRenderContext(); 63 ASSERT_NE(renderContext, nullptr); 64 auto borderImage = AceType::MakeRefPtr<BorderImage>(); 65 auto outsetDimension = Dimension(5.0); 66 borderImage->SetEdgeOutset(BorderImageDirection::START, outsetDimension); 67 renderContext->UpdateBorderImage(borderImage); 68 69 auto textDirection = TextDirection::LTR; 70 layoutProperty->CheckLocalizedBorderImageOutset(textDirection); 71 EXPECT_EQ(borderImage->GetBorderImageEdge(BorderImageDirection::LEFT).GetBorderImageOutset(), outsetDimension); 72 73 textDirection = TextDirection::RTL; 74 layoutProperty->CheckLocalizedBorderImageOutset(textDirection); 75 EXPECT_EQ(borderImage->GetBorderImageEdge(BorderImageDirection::RIGHT).GetBorderImageOutset(), outsetDimension); 76 } 77 78 /** 79 * @tc.name: CheckLocalizedBorderImageOutset002 80 * @tc.desc: Test CheckLocalizedBorderImageOutset when borderImageEnd_ has value 81 * @tc.type: FUNC 82 */ 83 HWTEST_F(LayoutPropertyTestNgTwo, CheckLocalizedBorderImageOutset002, TestSize.Level1) 84 { 85 auto layoutProperty = AceType::MakeRefPtr<LayoutProperty>(); 86 auto frameNodeHost = FrameNode::CreateFrameNode("host", 1, AceType::MakeRefPtr<Pattern>(), true); 87 layoutProperty->SetHost(frameNodeHost); 88 89 auto renderContext = frameNodeHost->GetRenderContext(); 90 ASSERT_NE(renderContext, nullptr); 91 auto borderImage = AceType::MakeRefPtr<BorderImage>(); 92 auto outsetDimension = Dimension(5.0); 93 borderImage->SetEdgeOutset(BorderImageDirection::END, outsetDimension); 94 renderContext->UpdateBorderImage(borderImage); 95 96 auto textDirection = TextDirection::LTR; 97 layoutProperty->CheckLocalizedBorderImageOutset(textDirection); 98 EXPECT_EQ(borderImage->GetBorderImageEdge(BorderImageDirection::RIGHT).GetBorderImageOutset(), outsetDimension); 99 100 textDirection = TextDirection::RTL; 101 layoutProperty->CheckLocalizedBorderImageOutset(textDirection); 102 EXPECT_EQ(borderImage->GetBorderImageEdge(BorderImageDirection::LEFT).GetBorderImageOutset(), outsetDimension); 103 } 104 105 /** 106 * @tc.name: CheckLocalizedBorderImageOutset003 107 * @tc.desc: Test CheckLocalizedBorderImageOutset When neither borderImageStart_ nor borderImageEnd_ has a value 108 * @tc.type: FUNC 109 */ 110 HWTEST_F(LayoutPropertyTestNgTwo, CheckLocalizedBorderImageOutset003, TestSize.Level1) 111 { 112 auto layoutProperty = AceType::MakeRefPtr<LayoutProperty>(); 113 auto frameNodeHost = FrameNode::CreateFrameNode("host", 1, AceType::MakeRefPtr<Pattern>(), true); 114 layoutProperty->SetHost(frameNodeHost); 115 116 auto renderContext = frameNodeHost->GetRenderContext(); 117 ASSERT_NE(renderContext, nullptr); 118 auto borderImage = AceType::MakeRefPtr<BorderImage>(); 119 renderContext->UpdateBorderImage(borderImage); 120 121 auto textDirection = TextDirection::LTR; 122 layoutProperty->CheckLocalizedBorderImageOutset(textDirection); 123 EXPECT_FALSE(borderImage->GetBorderImageEdge(BorderImageDirection::RIGHT).GetBorderImageOutset().IsValid()); 124 EXPECT_FALSE(borderImage->GetBorderImageEdge(BorderImageDirection::LEFT).GetBorderImageOutset().IsValid()); 125 } 126 127 /** 128 * @tc.name: CheckLocalizedBorderImageWidth001 129 * @tc.desc: Test CheckLocalizedBorderImageWidth when borderImageStart_ has value 130 * @tc.type: FUNC 131 */ 132 HWTEST_F(LayoutPropertyTestNgTwo, CheckLocalizedBorderImageWidth001, TestSize.Level1) 133 { 134 auto layoutProperty = AceType::MakeRefPtr<LayoutProperty>(); 135 auto frameNodeHost = FrameNode::CreateFrameNode("host", 1, AceType::MakeRefPtr<Pattern>(), true); 136 layoutProperty->SetHost(frameNodeHost); 137 138 auto renderContext = frameNodeHost->GetRenderContext(); 139 ASSERT_NE(renderContext, nullptr); 140 auto borderImage = AceType::MakeRefPtr<BorderImage>(); 141 auto widthDimension = Dimension(5.0); 142 borderImage->SetEdgeWidth(BorderImageDirection::START, widthDimension); 143 renderContext->UpdateBorderImage(borderImage); 144 145 auto textDirection = TextDirection::LTR; 146 layoutProperty->CheckLocalizedBorderImageWidth(textDirection); 147 EXPECT_EQ(borderImage->GetBorderImageEdge(BorderImageDirection::LEFT).GetBorderImageWidth(), widthDimension); 148 149 textDirection = TextDirection::RTL; 150 layoutProperty->CheckLocalizedBorderImageWidth(textDirection); 151 EXPECT_EQ(borderImage->GetBorderImageEdge(BorderImageDirection::RIGHT).GetBorderImageWidth(), widthDimension); 152 } 153 154 /** 155 * @tc.name: CheckLocalizedBorderImageWidth002 156 * @tc.desc: Test CheckLocalizedBorderImageWidth when borderImageEnd_ has value 157 * @tc.type: FUNC 158 */ 159 HWTEST_F(LayoutPropertyTestNgTwo, CheckLocalizedBorderImageWidth002, TestSize.Level1) 160 { 161 auto layoutProperty = AceType::MakeRefPtr<LayoutProperty>(); 162 auto frameNodeHost = FrameNode::CreateFrameNode("host", 1, AceType::MakeRefPtr<Pattern>(), true); 163 layoutProperty->SetHost(frameNodeHost); 164 165 auto renderContext = frameNodeHost->GetRenderContext(); 166 ASSERT_NE(renderContext, nullptr); 167 auto borderImage = AceType::MakeRefPtr<BorderImage>(); 168 auto widthDimension = Dimension(5.0); 169 borderImage->SetEdgeWidth(BorderImageDirection::END, widthDimension); 170 renderContext->UpdateBorderImage(borderImage); 171 172 auto textDirection = TextDirection::LTR; 173 layoutProperty->CheckLocalizedBorderImageWidth(textDirection); 174 EXPECT_EQ(borderImage->GetBorderImageEdge(BorderImageDirection::RIGHT).GetBorderImageWidth(), widthDimension); 175 176 textDirection = TextDirection::RTL; 177 layoutProperty->CheckLocalizedBorderImageWidth(textDirection); 178 EXPECT_EQ(borderImage->GetBorderImageEdge(BorderImageDirection::LEFT).GetBorderImageWidth(), widthDimension); 179 } 180 181 /** 182 * @tc.name: CheckLocalizedBorderImageWidth003 183 * @tc.desc: Test CheckLocalizedBorderImageWidth When neither borderImageStart_ nor borderImageEnd_ has a value 184 * @tc.type: FUNC 185 */ 186 HWTEST_F(LayoutPropertyTestNgTwo, CheckLocalizedBorderImageWidth003, TestSize.Level1) 187 { 188 auto layoutProperty = AceType::MakeRefPtr<LayoutProperty>(); 189 auto frameNodeHost = FrameNode::CreateFrameNode("host", 1, AceType::MakeRefPtr<Pattern>(), true); 190 layoutProperty->SetHost(frameNodeHost); 191 192 auto renderContext = frameNodeHost->GetRenderContext(); 193 ASSERT_NE(renderContext, nullptr); 194 auto borderImage = AceType::MakeRefPtr<BorderImage>(); 195 renderContext->UpdateBorderImage(borderImage); 196 197 auto textDirection = TextDirection::LTR; 198 layoutProperty->CheckLocalizedBorderImageWidth(textDirection); 199 EXPECT_FALSE(borderImage->GetBorderImageEdge(BorderImageDirection::RIGHT).GetBorderImageWidth().IsValid()); 200 EXPECT_FALSE(borderImage->GetBorderImageEdge(BorderImageDirection::LEFT).GetBorderImageWidth().IsValid()); 201 } 202 203 /** 204 * @tc.name: CheckLocalizedBorderImageSlice001 205 * @tc.desc: Test CheckLocalizedBorderImageSlice when borderImageStart_ has value 206 * @tc.type: FUNC 207 */ 208 HWTEST_F(LayoutPropertyTestNgTwo, CheckLocalizedBorderImageSlice001, TestSize.Level1) 209 { 210 auto layoutProperty = AceType::MakeRefPtr<LayoutProperty>(); 211 auto frameNodeHost = FrameNode::CreateFrameNode("host", 1, AceType::MakeRefPtr<Pattern>(), true); 212 layoutProperty->SetHost(frameNodeHost); 213 214 auto renderContext = frameNodeHost->GetRenderContext(); 215 ASSERT_NE(renderContext, nullptr); 216 auto borderImage = AceType::MakeRefPtr<BorderImage>(); 217 auto sliceDimension = Dimension(5.0); 218 borderImage->SetEdgeSlice(BorderImageDirection::START, sliceDimension); 219 renderContext->UpdateBorderImage(borderImage); 220 221 auto textDirection = TextDirection::LTR; 222 layoutProperty->CheckLocalizedBorderImageSlice(textDirection); 223 EXPECT_EQ(borderImage->GetBorderImageEdge(BorderImageDirection::LEFT).GetBorderImageSlice(), sliceDimension); 224 225 textDirection = TextDirection::RTL; 226 layoutProperty->CheckLocalizedBorderImageSlice(textDirection); 227 EXPECT_EQ(borderImage->GetBorderImageEdge(BorderImageDirection::RIGHT).GetBorderImageSlice(), sliceDimension); 228 } 229 230 /** 231 * @tc.name: CheckLocalizedBorderImageSlice002 232 * @tc.desc: Test CheckLocalizedBorderImageSlice when borderImageEnd_ has value 233 * @tc.type: FUNC 234 */ 235 HWTEST_F(LayoutPropertyTestNgTwo, CheckLocalizedBorderImageSlice002, TestSize.Level1) 236 { 237 auto layoutProperty = AceType::MakeRefPtr<LayoutProperty>(); 238 auto frameNodeHost = FrameNode::CreateFrameNode("host", 1, AceType::MakeRefPtr<Pattern>(), true); 239 layoutProperty->SetHost(frameNodeHost); 240 241 auto renderContext = frameNodeHost->GetRenderContext(); 242 ASSERT_NE(renderContext, nullptr); 243 auto borderImage = AceType::MakeRefPtr<BorderImage>(); 244 auto sliceDimension = Dimension(5.0); 245 borderImage->SetEdgeSlice(BorderImageDirection::END, sliceDimension); 246 renderContext->UpdateBorderImage(borderImage); 247 248 auto textDirection = TextDirection::LTR; 249 layoutProperty->CheckLocalizedBorderImageSlice(textDirection); 250 EXPECT_EQ(borderImage->GetBorderImageEdge(BorderImageDirection::RIGHT).GetBorderImageSlice(), sliceDimension); 251 252 textDirection = TextDirection::RTL; 253 layoutProperty->CheckLocalizedBorderImageSlice(textDirection); 254 EXPECT_EQ(borderImage->GetBorderImageEdge(BorderImageDirection::LEFT).GetBorderImageSlice(), sliceDimension); 255 } 256 257 /** 258 * @tc.name: CheckLocalizedBorderImageSlice003 259 * @tc.desc: Test CheckLocalizedBorderImageSlice When neither borderImageStart_ nor borderImageEnd_ has a value 260 * @tc.type: FUNC 261 */ 262 HWTEST_F(LayoutPropertyTestNgTwo, CheckLocalizedBorderImageSlice003, TestSize.Level1) 263 { 264 auto layoutProperty = AceType::MakeRefPtr<LayoutProperty>(); 265 auto frameNodeHost = FrameNode::CreateFrameNode("host", 1, AceType::MakeRefPtr<Pattern>(), true); 266 layoutProperty->SetHost(frameNodeHost); 267 268 auto renderContext = frameNodeHost->GetRenderContext(); 269 ASSERT_NE(renderContext, nullptr); 270 auto borderImage = AceType::MakeRefPtr<BorderImage>(); 271 renderContext->UpdateBorderImage(borderImage); 272 273 auto textDirection = TextDirection::LTR; 274 layoutProperty->CheckLocalizedBorderImageSlice(textDirection); 275 EXPECT_FALSE(borderImage->GetBorderImageEdge(BorderImageDirection::RIGHT).GetBorderImageSlice().IsValid()); 276 EXPECT_FALSE(borderImage->GetBorderImageEdge(BorderImageDirection::LEFT).GetBorderImageSlice().IsValid()); 277 } 278 279 /** 280 * @tc.name: CheckLocalizedEdgeColors001 281 * @tc.desc: Test CheckLocalizedEdgeColors when startColor has value 282 * @tc.type: FUNC 283 */ 284 HWTEST_F(LayoutPropertyTestNgTwo, CheckLocalizedEdgeColors001, TestSize.Level1) 285 { 286 auto layoutProperty = AceType::MakeRefPtr<LayoutProperty>(); 287 auto frameNodeHost = FrameNode::CreateFrameNode("host", 1, AceType::MakeRefPtr<Pattern>(), true); 288 layoutProperty->SetHost(frameNodeHost); 289 290 auto renderContext = frameNodeHost->GetRenderContext(); 291 ASSERT_NE(renderContext, nullptr); 292 BorderColorProperty borderColorProperty; 293 borderColorProperty.startColor = std::make_optional<Color>(Color::BLUE); 294 renderContext->UpdateBorderColor(borderColorProperty); 295 296 auto textDirection = TextDirection::LTR; 297 layoutProperty->CheckLocalizedEdgeColors(textDirection); 298 ASSERT_NE(renderContext->GetBorder(), nullptr); 299 EXPECT_EQ(renderContext->GetBorder()->GetBorderColorValue().leftColor.value(), Color::BLUE); 300 301 textDirection = TextDirection::RTL; 302 layoutProperty->CheckLocalizedEdgeColors(textDirection); 303 ASSERT_NE(renderContext->GetBorder(), nullptr); 304 EXPECT_EQ(renderContext->GetBorder()->GetBorderColorValue().rightColor.value(), Color::BLUE); 305 } 306 307 /** 308 * @tc.name: CheckLocalizedEdgeColors002 309 * @tc.desc: Test CheckLocalizedEdgeColors when endColor,topColor,bottomColor all have values 310 * @tc.type: FUNC 311 */ 312 HWTEST_F(LayoutPropertyTestNgTwo, CheckLocalizedEdgeColors002, TestSize.Level1) 313 { 314 auto layoutProperty = AceType::MakeRefPtr<LayoutProperty>(); 315 auto frameNodeHost = FrameNode::CreateFrameNode("host", 1, AceType::MakeRefPtr<Pattern>(), true); 316 layoutProperty->SetHost(frameNodeHost); 317 318 auto renderContext = frameNodeHost->GetRenderContext(); 319 ASSERT_NE(renderContext, nullptr); 320 BorderColorProperty borderColorProperty; 321 borderColorProperty.endColor = std::make_optional<Color>(Color::BLUE); 322 borderColorProperty.topColor = std::make_optional<Color>(Color::RED); 323 borderColorProperty.bottomColor = std::make_optional<Color>(Color::GREEN); 324 renderContext->UpdateBorderColor(borderColorProperty); 325 326 auto textDirection = TextDirection::LTR; 327 layoutProperty->CheckLocalizedEdgeColors(textDirection); 328 ASSERT_NE(renderContext->GetBorder(), nullptr); 329 EXPECT_EQ(renderContext->GetBorder()->GetBorderColorValue().rightColor.value(), Color::BLUE); 330 331 textDirection = TextDirection::RTL; 332 layoutProperty->CheckLocalizedEdgeColors(textDirection); 333 ASSERT_NE(renderContext->GetBorder(), nullptr); 334 EXPECT_EQ(renderContext->GetBorder()->GetBorderColorValue().leftColor.value(), Color::BLUE); 335 EXPECT_EQ(renderContext->GetBorder()->GetBorderColorValue().topColor.value(), Color::RED); 336 } 337 338 /** 339 * @tc.name: CheckLocalizedEdgeColors003 340 * @tc.desc: Test CheckLocalizedEdgeColors When neither startColor nor endColor has a value 341 * @tc.type: FUNC 342 */ 343 HWTEST_F(LayoutPropertyTestNgTwo, CheckLocalizedEdgeColors003, TestSize.Level1) 344 { 345 auto layoutProperty = AceType::MakeRefPtr<LayoutProperty>(); 346 auto frameNodeHost = FrameNode::CreateFrameNode("host", 1, AceType::MakeRefPtr<Pattern>(), true); 347 layoutProperty->SetHost(frameNodeHost); 348 349 auto renderContext = frameNodeHost->GetRenderContext(); 350 ASSERT_NE(renderContext, nullptr); 351 BorderColorProperty borderColorProperty; 352 renderContext->UpdateBorderColor(borderColorProperty); 353 354 auto textDirection = TextDirection::LTR; 355 layoutProperty->CheckLocalizedEdgeColors(textDirection); 356 ASSERT_NE(renderContext->GetBorder(), nullptr); 357 EXPECT_EQ(renderContext->GetBorder()->GetBorderColorValue().multiValued, false); 358 } 359 360 /** 361 * @tc.name: CheckLocalizedEdgeWidths001 362 * @tc.desc: Test CheckLocalizedEdgeWidths when startDimen,topDimen,bottomDimen,leftDimen all have values 363 * @tc.type: FUNC 364 */ 365 HWTEST_F(LayoutPropertyTestNgTwo, CheckLocalizedEdgeWidths001, TestSize.Level1) 366 { 367 auto layoutProperty = AceType::MakeRefPtr<LayoutProperty>(); 368 auto frameNodeHost = FrameNode::CreateFrameNode("host", 1, AceType::MakeRefPtr<Pattern>(), true); 369 layoutProperty->SetHost(frameNodeHost); 370 371 auto renderContext = frameNodeHost->GetRenderContext(); 372 ASSERT_NE(renderContext, nullptr); 373 BorderWidthProperty borderWidth; 374 auto startDimen = Dimension(5.0); 375 borderWidth.startDimen = std::make_optional<Dimension>(5.0); 376 borderWidth.topDimen = std::make_optional<Dimension>(6.0); 377 borderWidth.bottomDimen = std::make_optional<Dimension>(7.0); 378 borderWidth.leftDimen = std::make_optional<Dimension>(8.0); 379 renderContext->UpdateBorderWidth(borderWidth); 380 381 auto textDirection = TextDirection::LTR; 382 layoutProperty->CheckLocalizedEdgeWidths(layoutProperty, textDirection); 383 ASSERT_NE(layoutProperty->GetBorderWidthProperty(), nullptr); 384 EXPECT_EQ(layoutProperty->GetBorderWidthProperty()->leftDimen, startDimen); 385 386 textDirection = TextDirection::RTL; 387 layoutProperty->CheckLocalizedEdgeWidths(layoutProperty, textDirection); 388 ASSERT_NE(layoutProperty->GetBorderWidthProperty(), nullptr); 389 EXPECT_EQ(layoutProperty->GetBorderWidthProperty()->rightDimen, startDimen); 390 } 391 392 /** 393 * @tc.name: CheckLocalizedEdgeWidths002 394 * @tc.desc: Test CheckLocalizedEdgeWidths when endDimen,rightDimen have values 395 * @tc.type: FUNC 396 */ 397 HWTEST_F(LayoutPropertyTestNgTwo, CheckLocalizedEdgeWidths002, TestSize.Level1) 398 { 399 auto layoutProperty = AceType::MakeRefPtr<LayoutProperty>(); 400 auto frameNodeHost = FrameNode::CreateFrameNode("host", 1, AceType::MakeRefPtr<Pattern>(), true); 401 layoutProperty->SetHost(frameNodeHost); 402 403 auto renderContext = frameNodeHost->GetRenderContext(); 404 ASSERT_NE(renderContext, nullptr); 405 BorderWidthProperty borderWidth; 406 auto endDimen = Dimension(5.0); 407 borderWidth.endDimen = std::make_optional<Dimension>(5.0); 408 borderWidth.rightDimen = std::make_optional<Dimension>(6.0); 409 renderContext->UpdateBorderWidth(borderWidth); 410 411 auto textDirection = TextDirection::LTR; 412 layoutProperty->CheckLocalizedEdgeWidths(layoutProperty, textDirection); 413 ASSERT_NE(layoutProperty->GetBorderWidthProperty(), nullptr); 414 EXPECT_EQ(layoutProperty->GetBorderWidthProperty()->rightDimen, endDimen); 415 416 textDirection = TextDirection::RTL; 417 layoutProperty->CheckLocalizedEdgeWidths(layoutProperty, textDirection); 418 ASSERT_NE(layoutProperty->GetBorderWidthProperty(), nullptr); 419 EXPECT_EQ(layoutProperty->GetBorderWidthProperty()->leftDimen, endDimen); 420 } 421 422 /** 423 * @tc.name: CheckLocalizedEdgeWidths003 424 * @tc.desc: Test CheckLocalizedEdgeWidths When neither startDimen nor endDimen has a value 425 * @tc.type: FUNC 426 */ 427 HWTEST_F(LayoutPropertyTestNgTwo, CheckLocalizedEdgeWidths003, TestSize.Level1) 428 { 429 auto layoutProperty = AceType::MakeRefPtr<LayoutProperty>(); 430 auto frameNodeHost = FrameNode::CreateFrameNode("host", 1, AceType::MakeRefPtr<Pattern>(), true); 431 layoutProperty->SetHost(frameNodeHost); 432 433 auto renderContext = frameNodeHost->GetRenderContext(); 434 ASSERT_NE(renderContext, nullptr); 435 BorderWidthProperty borderWidth; 436 renderContext->UpdateBorderWidth(borderWidth); 437 438 auto textDirection = TextDirection::LTR; 439 layoutProperty->CheckLocalizedEdgeWidths(layoutProperty, textDirection); 440 ASSERT_NE(renderContext->GetBorder(), nullptr); 441 EXPECT_EQ(renderContext->GetBorder()->GetBorderWidthValue().multiValued, false); 442 } 443 444 /** 445 * @tc.name: CheckLocalizedMargin001 446 * @tc.desc: Test CheckLocalizedMargin when start,top,bottom,left have values 447 * @tc.type: FUNC 448 */ 449 HWTEST_F(LayoutPropertyTestNgTwo, CheckLocalizedMargin001, TestSize.Level1) 450 { 451 auto layoutProperty = AceType::MakeRefPtr<LayoutProperty>(); 452 auto frameNodeHost = FrameNode::CreateFrameNode("host", 1, AceType::MakeRefPtr<Pattern>(), true); 453 layoutProperty->SetHost(frameNodeHost); 454 455 PaddingPropertyT<CalcLength> paddingProperty; 456 paddingProperty.start = std::make_optional<CalcLength>(5.0); 457 paddingProperty.top = std::make_optional<CalcLength>(6.0); 458 paddingProperty.bottom = std::make_optional<CalcLength>(7.0); 459 paddingProperty.left = std::make_optional<CalcLength>(8.0); 460 layoutProperty->UpdateMargin(paddingProperty); 461 462 auto textDirection = TextDirection::LTR; 463 layoutProperty->CheckLocalizedMargin(layoutProperty, textDirection); 464 auto& marginProperty = layoutProperty->GetMarginProperty(); 465 ASSERT_NE(marginProperty, nullptr); 466 EXPECT_EQ(marginProperty->left.value(), CalcLength(5.0)); 467 468 textDirection = TextDirection::RTL; 469 layoutProperty->CheckLocalizedMargin(layoutProperty, textDirection); 470 ASSERT_NE(marginProperty, nullptr); 471 EXPECT_EQ(marginProperty->right.value(), CalcLength(5.0)); 472 } 473 474 /** 475 * @tc.name: CheckLocalizedMargin002 476 * @tc.desc: Test CheckLocalizedMargin when end,right have values 477 * @tc.type: FUNC 478 */ 479 HWTEST_F(LayoutPropertyTestNgTwo, CheckLocalizedMargin002, TestSize.Level1) 480 { 481 auto layoutProperty = AceType::MakeRefPtr<LayoutProperty>(); 482 auto frameNodeHost = FrameNode::CreateFrameNode("host", 1, AceType::MakeRefPtr<Pattern>(), true); 483 layoutProperty->SetHost(frameNodeHost); 484 485 PaddingPropertyT<CalcLength> paddingProperty; 486 paddingProperty.end = std::make_optional<CalcLength>(5.0); 487 paddingProperty.right = std::make_optional<CalcLength>(6.0); 488 layoutProperty->UpdateMargin(paddingProperty); 489 490 auto textDirection = TextDirection::LTR; 491 layoutProperty->CheckLocalizedMargin(layoutProperty, textDirection); 492 auto& marginProperty = layoutProperty->GetMarginProperty(); 493 ASSERT_NE(marginProperty, nullptr); 494 EXPECT_EQ(marginProperty->right.value(), CalcLength(5.0)); 495 496 textDirection = TextDirection::RTL; 497 layoutProperty->CheckLocalizedMargin(layoutProperty, textDirection); 498 ASSERT_NE(marginProperty, nullptr); 499 EXPECT_EQ(marginProperty->left.value(), CalcLength(5.0)); 500 } 501 502 /** 503 * @tc.name: CheckLocalizedMargin003 504 * @tc.desc: Test CheckLocalizedMargin When neither start nor end has a value 505 * @tc.type: FUNC 506 */ 507 HWTEST_F(LayoutPropertyTestNgTwo, CheckLocalizedMargin003, TestSize.Level1) 508 { 509 auto layoutProperty = AceType::MakeRefPtr<LayoutProperty>(); 510 auto frameNodeHost = FrameNode::CreateFrameNode("host", 1, AceType::MakeRefPtr<Pattern>(), true); 511 layoutProperty->SetHost(frameNodeHost); 512 513 PaddingPropertyT<CalcLength> paddingProperty; 514 layoutProperty->UpdateMargin(paddingProperty); 515 516 auto textDirection = TextDirection::LTR; 517 layoutProperty->CheckLocalizedMargin(layoutProperty, textDirection); 518 auto& marginProperty = layoutProperty->GetMarginProperty(); 519 ASSERT_NE(marginProperty, nullptr); 520 EXPECT_FALSE(marginProperty->right.has_value()); 521 EXPECT_FALSE(marginProperty->left.has_value()); 522 } 523 524 /** 525 * @tc.name: CheckLocalizedPadding001 526 * @tc.desc: Test CheckLocalizedPadding when start,top,bottom,left have values 527 * @tc.type: FUNC 528 */ 529 HWTEST_F(LayoutPropertyTestNgTwo, CheckLocalizedPadding001, TestSize.Level1) 530 { 531 auto layoutProperty = AceType::MakeRefPtr<LayoutProperty>(); 532 auto frameNodeHost = FrameNode::CreateFrameNode("host", 1, AceType::MakeRefPtr<Pattern>(), true); 533 layoutProperty->SetHost(frameNodeHost); 534 535 PaddingPropertyT<CalcLength> paddingProperty; 536 paddingProperty.start = std::make_optional<CalcLength>(5.0); 537 paddingProperty.top = std::make_optional<CalcLength>(6.0); 538 paddingProperty.bottom = std::make_optional<CalcLength>(7.0); 539 paddingProperty.left = std::make_optional<CalcLength>(8.0); 540 layoutProperty->UpdatePadding(paddingProperty); 541 542 auto textDirection = TextDirection::LTR; 543 layoutProperty->CheckLocalizedPadding(layoutProperty, textDirection); 544 auto& padding = layoutProperty->GetPaddingProperty(); 545 ASSERT_NE(padding, nullptr); 546 EXPECT_EQ(padding->left.value(), CalcLength(5.0)); 547 548 textDirection = TextDirection::RTL; 549 layoutProperty->CheckLocalizedPadding(layoutProperty, textDirection); 550 ASSERT_NE(padding, nullptr); 551 EXPECT_EQ(padding->right.value(), CalcLength(5.0)); 552 } 553 554 /** 555 * @tc.name: CheckLocalizedPadding002 556 * @tc.desc: Test CheckLocalizedPadding when end,right have values 557 * @tc.type: FUNC 558 */ 559 HWTEST_F(LayoutPropertyTestNgTwo, CheckLocalizedPadding002, TestSize.Level1) 560 { 561 auto layoutProperty = AceType::MakeRefPtr<LayoutProperty>(); 562 auto frameNodeHost = FrameNode::CreateFrameNode("host", 1, AceType::MakeRefPtr<Pattern>(), true); 563 layoutProperty->SetHost(frameNodeHost); 564 565 PaddingPropertyT<CalcLength> paddingProperty; 566 paddingProperty.end = std::make_optional<CalcLength>(5.0); 567 paddingProperty.right = std::make_optional<CalcLength>(6.0); 568 layoutProperty->UpdatePadding(paddingProperty); 569 570 auto textDirection = TextDirection::LTR; 571 layoutProperty->CheckLocalizedPadding(layoutProperty, textDirection); 572 auto& padding = layoutProperty->GetPaddingProperty(); 573 ASSERT_NE(padding, nullptr); 574 EXPECT_EQ(padding->right.value(), CalcLength(5.0)); 575 576 textDirection = TextDirection::RTL; 577 layoutProperty->CheckLocalizedPadding(layoutProperty, textDirection); 578 ASSERT_NE(padding, nullptr); 579 EXPECT_EQ(padding->left.value(), CalcLength(5.0)); 580 } 581 582 /** 583 * @tc.name: CheckLocalizedPadding003 584 * @tc.desc: Test CheckLocalizedPadding When neither start nor end has a value 585 * @tc.type: FUNC 586 */ 587 HWTEST_F(LayoutPropertyTestNgTwo, CheckLocalizedPadding003, TestSize.Level1) 588 { 589 auto layoutProperty = AceType::MakeRefPtr<LayoutProperty>(); 590 auto frameNodeHost = FrameNode::CreateFrameNode("host", 1, AceType::MakeRefPtr<Pattern>(), true); 591 layoutProperty->SetHost(frameNodeHost); 592 593 PaddingPropertyT<CalcLength> paddingProperty; 594 layoutProperty->UpdatePadding(paddingProperty); 595 596 auto textDirection = TextDirection::LTR; 597 layoutProperty->CheckLocalizedPadding(layoutProperty, textDirection); 598 auto& padding = layoutProperty->GetPaddingProperty(); 599 ASSERT_NE(padding, nullptr); 600 EXPECT_FALSE(padding->right.has_value()); 601 EXPECT_FALSE(padding->left.has_value()); 602 } 603 604 /** 605 * @tc.name: LocalizedPaddingOrMarginChange001 606 * @tc.desc: Test LocalizedPaddingOrMarginChange 607 * @tc.type: FUNC 608 */ 609 HWTEST_F(LayoutPropertyTestNgTwo, LocalizedPaddingOrMarginChange001, TestSize.Level1) 610 { 611 auto layoutProperty = AceType::MakeRefPtr<LayoutProperty>(); 612 613 PaddingPropertyT<CalcLength> paddingProperty1; 614 std::unique_ptr<PaddingProperty> PaddingProperty2 = std::make_unique<PaddingProperty>(); 615 616 layoutProperty->LocalizedPaddingOrMarginChange(paddingProperty1, PaddingProperty2); 617 618 paddingProperty1.end = std::make_optional<CalcLength>(5.0); 619 layoutProperty->LocalizedPaddingOrMarginChange(paddingProperty1, PaddingProperty2); 620 EXPECT_EQ(PaddingProperty2->end.value(), CalcLength(5.0)); 621 622 paddingProperty1.start = std::make_optional<CalcLength>(5.0); 623 layoutProperty->LocalizedPaddingOrMarginChange(paddingProperty1, PaddingProperty2); 624 EXPECT_EQ(PaddingProperty2->start.value(), CalcLength(5.0)); 625 } 626 627 /** 628 * @tc.name: CheckLocalizedOuterBorderColor001 629 * @tc.desc: Test CheckLocalizedOuterBorderColor when startColor has value 630 * @tc.type: FUNC 631 */ 632 HWTEST_F(LayoutPropertyTestNgTwo, CheckLocalizedOuterBorderColor001, TestSize.Level1) 633 { 634 auto layoutProperty = AceType::MakeRefPtr<LayoutProperty>(); 635 auto frameNodeHost = FrameNode::CreateFrameNode("host", 1, AceType::MakeRefPtr<Pattern>(), true); 636 layoutProperty->SetHost(frameNodeHost); 637 638 auto renderContext = frameNodeHost->GetRenderContext(); 639 ASSERT_NE(renderContext, nullptr); 640 BorderColorProperty borderColorProperty; 641 borderColorProperty.startColor = std::make_optional<Color>(Color::BLUE); 642 renderContext->UpdateOuterBorderColor(borderColorProperty); 643 644 auto textDirection = TextDirection::LTR; 645 layoutProperty->CheckLocalizedOuterBorderColor(textDirection); 646 ASSERT_NE(renderContext->GetOuterBorder(), nullptr); 647 EXPECT_EQ(renderContext->GetOuterBorder()->GetOuterBorderColorValue().leftColor.value(), Color::BLUE); 648 649 textDirection = TextDirection::RTL; 650 layoutProperty->CheckLocalizedOuterBorderColor(textDirection); 651 ASSERT_NE(renderContext->GetOuterBorder(), nullptr); 652 EXPECT_EQ(renderContext->GetOuterBorder()->GetOuterBorderColorValue().rightColor.value(), Color::BLUE); 653 } 654 655 /** 656 * @tc.name: CheckLocalizedOuterBorderColor002 657 * @tc.desc: Test CheckLocalizedOuterBorderColor when endColor,topColor,bottomColor have values 658 * @tc.type: FUNC 659 */ 660 HWTEST_F(LayoutPropertyTestNgTwo, CheckLocalizedOuterBorderColor002, TestSize.Level1) 661 { 662 auto layoutProperty = AceType::MakeRefPtr<LayoutProperty>(); 663 auto frameNodeHost = FrameNode::CreateFrameNode("host", 1, AceType::MakeRefPtr<Pattern>(), true); 664 layoutProperty->SetHost(frameNodeHost); 665 666 auto renderContext = frameNodeHost->GetRenderContext(); 667 ASSERT_NE(renderContext, nullptr); 668 BorderColorProperty borderColorProperty; 669 borderColorProperty.endColor = std::make_optional<Color>(Color::BLUE); 670 borderColorProperty.topColor = std::make_optional<Color>(Color::RED); 671 borderColorProperty.bottomColor = std::make_optional<Color>(Color::GREEN); 672 renderContext->UpdateOuterBorderColor(borderColorProperty); 673 674 auto textDirection = TextDirection::LTR; 675 layoutProperty->CheckLocalizedOuterBorderColor(textDirection); 676 layoutProperty->CheckLocalizedOuterBorderColor(textDirection); 677 ASSERT_NE(renderContext->GetOuterBorder(), nullptr); 678 EXPECT_EQ(renderContext->GetOuterBorder()->GetOuterBorderColorValue().rightColor.value(), Color::BLUE); 679 680 textDirection = TextDirection::RTL; 681 layoutProperty->CheckLocalizedOuterBorderColor(textDirection); 682 ASSERT_NE(renderContext->GetOuterBorder(), nullptr); 683 EXPECT_EQ(renderContext->GetOuterBorder()->GetOuterBorderColorValue().leftColor.value(), Color::BLUE); 684 } 685 686 /** 687 * @tc.name: CheckLocalizedOuterBorderColor003 688 * @tc.desc: Test CheckLocalizedOuterBorderColor When neither startColor nor endColor has a value 689 * @tc.type: FUNC 690 */ 691 HWTEST_F(LayoutPropertyTestNgTwo, CheckLocalizedOuterBorderColor003, TestSize.Level1) 692 { 693 auto layoutProperty = AceType::MakeRefPtr<LayoutProperty>(); 694 auto frameNodeHost = FrameNode::CreateFrameNode("host", 1, AceType::MakeRefPtr<Pattern>(), true); 695 layoutProperty->SetHost(frameNodeHost); 696 697 auto renderContext = frameNodeHost->GetRenderContext(); 698 ASSERT_NE(renderContext, nullptr); 699 BorderColorProperty borderColorProperty; 700 renderContext->UpdateOuterBorderColor(borderColorProperty); 701 702 auto textDirection = TextDirection::LTR; 703 layoutProperty->CheckLocalizedOuterBorderColor(textDirection); 704 ASSERT_NE(renderContext->GetOuterBorder(), nullptr); 705 EXPECT_FALSE(renderContext->GetOuterBorder()->GetOuterBorderColorValue().rightColor.has_value()); 706 EXPECT_FALSE(renderContext->GetOuterBorder()->GetOuterBorderColorValue().leftColor.has_value()); 707 } 708 709 /** 710 * @tc.name: CheckLocalizedBorderRadiuses001 711 * @tc.desc: Test CheckLocalizedBorderRadiuses when radiusTopStart,radiusTopEnd, 712 * radiusBottomStart,radiusBottomEnd have values 713 * @tc.type: FUNC 714 */ 715 HWTEST_F(LayoutPropertyTestNgTwo, CheckLocalizedBorderRadiuses001, TestSize.Level1) 716 { 717 auto layoutProperty = AceType::MakeRefPtr<LayoutProperty>(); 718 auto frameNodeHost = FrameNode::CreateFrameNode("host", 1, AceType::MakeRefPtr<Pattern>(), true); 719 layoutProperty->SetHost(frameNodeHost); 720 721 BorderRadiusProperty borderRadius; 722 borderRadius.radiusTopStart = std::make_optional<Dimension>(5.0); 723 borderRadius.radiusTopEnd = std::make_optional<Dimension>(6.0); 724 borderRadius.radiusBottomStart = std::make_optional<Dimension>(7.0); 725 borderRadius.radiusBottomEnd = std::make_optional<Dimension>(8.0); 726 727 auto renderContext = frameNodeHost->GetRenderContext(); 728 ASSERT_NE(renderContext, nullptr); 729 renderContext->UpdateBorderRadius(borderRadius); 730 731 auto textDirection = TextDirection::LTR; 732 layoutProperty->CheckLocalizedBorderRadiuses(textDirection); 733 ASSERT_NE(renderContext->GetBorder(), nullptr); 734 EXPECT_EQ(renderContext->GetBorder()->GetBorderRadiusValue().radiusTopLeft.value(), Dimension(5.0)); 735 736 textDirection = TextDirection::RTL; 737 layoutProperty->CheckLocalizedBorderRadiuses(textDirection); 738 ASSERT_NE(renderContext->GetBorder(), nullptr); 739 EXPECT_EQ(renderContext->GetBorder()->GetBorderRadiusValue().radiusTopRight.value(), Dimension(5.0)); 740 } 741 742 /** 743 * @tc.name: CheckLocalizedBorderRadiuses002 744 * @tc.desc: Test CheckLocalizedBorderRadiuses when radiusTopStart,radiusTopEnd, 745 * radiusBottomStart,radiusBottomEnd have no values 746 * @tc.type: FUNC 747 */ 748 HWTEST_F(LayoutPropertyTestNgTwo, CheckLocalizedBorderRadiuses002, TestSize.Level1) 749 { 750 auto layoutProperty = AceType::MakeRefPtr<LayoutProperty>(); 751 auto frameNodeHost = FrameNode::CreateFrameNode("host", 1, AceType::MakeRefPtr<Pattern>(), true); 752 layoutProperty->SetHost(frameNodeHost); 753 754 BorderRadiusProperty borderRadius; 755 auto renderContext = frameNodeHost->GetRenderContext(); 756 ASSERT_NE(renderContext, nullptr); 757 renderContext->UpdateBorderRadius(borderRadius); 758 759 auto textDirection = TextDirection::LTR; 760 layoutProperty->CheckLocalizedBorderRadiuses(textDirection); 761 ASSERT_NE(renderContext->GetBorder(), nullptr); 762 EXPECT_FALSE(renderContext->GetBorder()->GetBorderRadiusValue().radiusTopLeft.has_value()); 763 EXPECT_FALSE(renderContext->GetBorder()->GetBorderRadiusValue().radiusTopRight.has_value()); 764 } 765 766 /** 767 * @tc.name: CheckLocalizedBorderRadiuses003 768 * @tc.desc: Test CheckLocalizedBorderRadiuses When one of radiusTopStart,radiusTopEnd, 769 * radiusBottomStart,radiusBottomEnd has a value 770 * @tc.type: FUNC 771 */ 772 HWTEST_F(LayoutPropertyTestNgTwo, CheckLocalizedBorderRadiuses003, TestSize.Level1) 773 { 774 auto layoutProperty = AceType::MakeRefPtr<LayoutProperty>(); 775 auto frameNodeHost = FrameNode::CreateFrameNode("host", 1, AceType::MakeRefPtr<Pattern>(), true); 776 layoutProperty->SetHost(frameNodeHost); 777 778 auto radiusTopStart = Dimension(5.0); 779 auto radiusTopEnd = Dimension(6.0); 780 auto radiusBottomStart = Dimension(7.0); 781 auto radiusBottomEnd = Dimension(8.0); 782 783 BorderRadiusProperty borderRadius; 784 auto renderContext = frameNodeHost->GetRenderContext(); 785 ASSERT_NE(renderContext, nullptr); 786 borderRadius.radiusTopStart = std::make_optional<Dimension>(radiusTopStart); 787 renderContext->UpdateBorderRadius(borderRadius); 788 789 auto textDirection = TextDirection::LTR; 790 layoutProperty->CheckLocalizedBorderRadiuses(textDirection); 791 ASSERT_NE(renderContext->GetBorder(), nullptr); 792 EXPECT_EQ(renderContext->GetBorder()->GetBorderRadiusValue().radiusTopLeft.value(), radiusTopStart); 793 794 borderRadius.radiusTopStart = std::nullopt; 795 borderRadius.radiusTopEnd = std::make_optional<Dimension>(radiusTopEnd); 796 renderContext->GetBorder()->UpdateBorderRadius(borderRadius); 797 layoutProperty->CheckLocalizedBorderRadiuses(textDirection); 798 EXPECT_EQ(renderContext->GetBorder()->GetBorderRadiusValue().radiusTopRight.value(), radiusTopEnd); 799 800 borderRadius.radiusTopEnd = std::nullopt; 801 borderRadius.radiusBottomStart = std::make_optional<Dimension>(radiusBottomStart); 802 renderContext->GetBorder()->UpdateBorderRadius(borderRadius); 803 layoutProperty->CheckLocalizedBorderRadiuses(textDirection); 804 EXPECT_EQ(renderContext->GetBorder()->GetBorderRadiusValue().radiusBottomLeft.value(), radiusBottomStart); 805 806 borderRadius.radiusBottomStart = std::nullopt; 807 borderRadius.radiusBottomEnd = std::make_optional<Dimension>(radiusBottomEnd); 808 renderContext->GetBorder()->UpdateBorderRadius(borderRadius); 809 layoutProperty->CheckLocalizedBorderRadiuses(textDirection); 810 EXPECT_EQ(renderContext->GetBorder()->GetBorderRadiusValue().radiusBottomRight.value(), radiusBottomEnd); 811 } 812 813 /** 814 * @tc.name: CheckOffsetLocalizedEdges001 815 * @tc.desc: Test CheckOffsetLocalizedEdges 816 * @tc.type: FUNC 817 */ 818 HWTEST_F(LayoutPropertyTestNgTwo, CheckOffsetLocalizedEdges001, TestSize.Level1) 819 { 820 auto layoutProperty = AceType::MakeRefPtr<LayoutProperty>(); 821 auto frameNodeHost = FrameNode::CreateFrameNode("host", 1, AceType::MakeRefPtr<Pattern>(), true); 822 layoutProperty->SetHost(frameNodeHost); 823 824 auto top = CalcDimension(1.0); 825 auto bottom = CalcDimension(2.0); 826 auto start = CalcDimension(3.0); 827 auto end = CalcDimension(4.0); 828 829 EdgesParam edges; 830 edges.SetTop(top); 831 edges.SetBottom(bottom); 832 edges.start = start; 833 edges.end = end; 834 835 auto renderContext = frameNodeHost->GetRenderContext(); 836 ASSERT_NE(renderContext, nullptr); 837 renderContext->UpdateOffsetEdges(edges); 838 839 auto textDirection = TextDirection::LTR; 840 layoutProperty->CheckOffsetLocalizedEdges(textDirection); 841 ASSERT_NE(renderContext->GetPositionProperty(), nullptr); 842 EXPECT_EQ(renderContext->GetPositionProperty()->GetOffsetEdgesValue().left.value(), start); 843 844 textDirection = TextDirection::RTL; 845 layoutProperty->CheckOffsetLocalizedEdges(textDirection); 846 ASSERT_NE(renderContext->GetPositionProperty(), nullptr); 847 EXPECT_EQ(renderContext->GetPositionProperty()->GetOffsetEdgesValue().left.value(), end); 848 } 849 850 /** 851 * @tc.name: CheckOffsetLocalizedEdges002 852 * @tc.desc: Test CheckOffsetLocalizedEdges 853 * @tc.type: FUNC 854 */ 855 HWTEST_F(LayoutPropertyTestNgTwo, CheckOffsetLocalizedEdges002, TestSize.Level1) 856 { 857 auto layoutProperty = AceType::MakeRefPtr<LayoutProperty>(); 858 auto frameNodeHost = FrameNode::CreateFrameNode("host", 1, AceType::MakeRefPtr<Pattern>(), true); 859 layoutProperty->SetHost(frameNodeHost); 860 861 EdgesParam edges; 862 863 auto renderContext = frameNodeHost->GetRenderContext(); 864 ASSERT_NE(renderContext, nullptr); 865 renderContext->UpdateOffsetEdges(edges); 866 867 auto textDirection = TextDirection::LTR; 868 layoutProperty->CheckOffsetLocalizedEdges(textDirection); 869 ASSERT_NE(renderContext->GetPositionProperty(), nullptr); 870 EXPECT_FALSE(renderContext->GetPositionProperty()->GetOffsetEdgesValue().left.has_value()); 871 EXPECT_FALSE(renderContext->GetPositionProperty()->GetOffsetEdgesValue().right.has_value()); 872 } 873 874 /** 875 * @tc.name: CheckPositionLocalizedEdges001 876 * @tc.desc: Test CheckPositionLocalizedEdges 877 * @tc.type: FUNC 878 */ 879 HWTEST_F(LayoutPropertyTestNgTwo, CheckPositionLocalizedEdges001, TestSize.Level1) 880 { 881 auto layoutProperty = AceType::MakeRefPtr<LayoutProperty>(); 882 auto frameNodeHost = FrameNode::CreateFrameNode("host", 1, AceType::MakeRefPtr<Pattern>(), true); 883 layoutProperty->SetHost(frameNodeHost); 884 885 auto top = CalcDimension(1.0); 886 auto bottom = CalcDimension(2.0); 887 auto start = CalcDimension(3.0); 888 auto end = CalcDimension(4.0); 889 890 EdgesParam edges; 891 edges.SetTop(top); 892 edges.SetBottom(bottom); 893 edges.start = start; 894 edges.end = end; 895 896 auto renderContext = frameNodeHost->GetRenderContext(); 897 ASSERT_NE(renderContext, nullptr); 898 renderContext->UpdatePositionEdges(edges); 899 900 auto textDirection = TextDirection::LTR; 901 layoutProperty->CheckPositionLocalizedEdges(textDirection); 902 ASSERT_NE(renderContext->GetPositionProperty(), nullptr); 903 EXPECT_EQ(renderContext->GetPositionProperty()->GetPositionEdgesValue().left.value(), start); 904 905 textDirection = TextDirection::RTL; 906 layoutProperty->CheckPositionLocalizedEdges(textDirection); 907 ASSERT_NE(renderContext->GetPositionProperty(), nullptr); 908 EXPECT_EQ(renderContext->GetPositionProperty()->GetPositionEdgesValue().left.value(), end); 909 } 910 911 /** 912 * @tc.name: CheckPositionLocalizedEdges002 913 * @tc.desc: Test CheckPositionLocalizedEdges 914 * @tc.type: FUNC 915 */ 916 HWTEST_F(LayoutPropertyTestNgTwo, CheckPositionLocalizedEdges002, TestSize.Level1) 917 { 918 auto layoutProperty = AceType::MakeRefPtr<LayoutProperty>(); 919 auto frameNodeHost = FrameNode::CreateFrameNode("host", 1, AceType::MakeRefPtr<Pattern>(), true); 920 layoutProperty->SetHost(frameNodeHost); 921 922 EdgesParam edges; 923 924 auto renderContext = frameNodeHost->GetRenderContext(); 925 ASSERT_NE(renderContext, nullptr); 926 renderContext->UpdatePositionEdges(edges); 927 928 auto textDirection = TextDirection::LTR; 929 layoutProperty->CheckPositionLocalizedEdges(textDirection); 930 ASSERT_NE(renderContext->GetPositionProperty(), nullptr); 931 EXPECT_FALSE(renderContext->GetPositionProperty()->GetPositionEdgesValue().left.has_value()); 932 EXPECT_FALSE(renderContext->GetPositionProperty()->GetPositionEdgesValue().right.has_value()); 933 } 934 935 /** 936 * @tc.name: ConstraintEqual001 937 * @tc.desc: Test ConstraintEqual when preContentConstraint is nullopt 938 * @tc.type: FUNC 939 */ 940 HWTEST_F(LayoutPropertyTestNgTwo, ConstraintEqual001, TestSize.Level1) 941 { 942 auto layoutProperty = AceType::MakeRefPtr<LayoutProperty>(); 943 944 auto preLayoutConstraint = std::make_optional<LayoutConstraintF>(); 945 auto preContentConstraint = std::make_optional<LayoutConstraintF>(); 946 preContentConstraint = std::nullopt; 947 948 layoutProperty->layoutConstraint_ = preLayoutConstraint; 949 bool bResult = layoutProperty->ConstraintEqual(preLayoutConstraint, preContentConstraint); 950 EXPECT_FALSE(bResult); 951 } 952 953 /** 954 * @tc.name: UpdateAllGeometryTransition001 955 * @tc.desc: Test UpdateAllGeometryTransition 956 * @tc.type: FUNC 957 */ 958 HWTEST_F(LayoutPropertyTestNgTwo, UpdateAllGeometryTransition001, TestSize.Level1) 959 { 960 auto layoutProperty = AceType::MakeRefPtr<LayoutProperty>(); 961 962 auto parentId = ElementRegister::GetInstance()->MakeUniqueId(); 963 auto parent = CustomNode::CreateCustomNode(parentId, "parent"); 964 layoutProperty->UpdateAllGeometryTransition(parent); 965 966 auto frameNodeHost = FrameNode::CreateFrameNode("host", 1, AceType::MakeRefPtr<Pattern>(), true); 967 layoutProperty->UpdateAllGeometryTransition(frameNodeHost); 968 EXPECT_FALSE(layoutProperty->GetGeometryTransition()); 969 } 970 971 /** 972 * @tc.name: FromJson001 973 * @tc.desc: Test FromJson 974 * @tc.type: FUNC 975 */ 976 HWTEST_F(LayoutPropertyTestNgTwo, FromJson001, TestSize.Level1) 977 { 978 auto layoutProperty = AceType::MakeRefPtr<LayoutProperty>(); 979 980 auto json = JsonUtil::Create(true); 981 json->Put("padding", "0.0"); 982 json->Put("margin", "0.0"); 983 json->Put("direction", "Direction.Rtl"); 984 layoutProperty->FromJson(json); 985 986 EXPECT_EQ(layoutProperty->GetNonAutoLayoutDirection(), TextDirection::RTL); 987 } 988 989 /** 990 * @tc.name: UpdateSafeAreaPadding001 991 * @tc.desc: Test UpdateSafeAreaPadding 992 * @tc.type: FUNC 993 */ 994 HWTEST_F(LayoutPropertyTestNgTwo, UpdateSafeAreaPadding001, TestSize.Level1) 995 { 996 auto layoutProperty = AceType::MakeRefPtr<LayoutProperty>(); 997 auto frameNodeHost = FrameNode::CreateFrameNode("host", 1, AceType::MakeRefPtr<Pattern>(), true); 998 layoutProperty->SetHost(frameNodeHost); 999 1000 PaddingProperty paddingProperty; 1001 layoutProperty->ResetSafeAreaPadding(); 1002 layoutProperty->UpdateSafeAreaPadding(paddingProperty); 1003 EXPECT_TRUE(layoutProperty->GetSafeAreaPaddingProperty()); 1004 1005 paddingProperty.start = std::make_optional<CalcLength>(5.0); 1006 layoutProperty->UpdateSafeAreaPadding(paddingProperty); 1007 layoutProperty->ResetSafeAreaPadding(); 1008 EXPECT_FALSE(layoutProperty->GetSafeAreaPaddingProperty()); 1009 } 1010 1011 /** 1012 * @tc.name: PixelRoundToJsonValue001 1013 * @tc.desc: Test PixelRoundToJsonValue 1014 * @tc.type: FUNC 1015 */ 1016 HWTEST_F(LayoutPropertyTestNgTwo, PixelRoundToJsonValue001, TestSize.Level1) 1017 { 1018 auto layoutProperty = AceType::MakeRefPtr<LayoutProperty>(); 1019 const std::string VALUE = "PixelRoundCalcPolicy.FORCE_CEIL"; 1020 1021 layoutProperty->pixelRoundFlag_ = static_cast<uint16_t>(PixelRoundPolicy::FORCE_CEIL_START); 1022 auto res = layoutProperty->PixelRoundToJsonValue(); 1023 auto jsonValue = JsonUtil::ParseJsonString(res); 1024 ASSERT_NE(jsonValue, nullptr); 1025 EXPECT_EQ(jsonValue->GetString("start"), VALUE); 1026 1027 layoutProperty->pixelRoundFlag_ = static_cast<uint16_t>(PixelRoundPolicy::FORCE_CEIL_TOP); 1028 res = layoutProperty->PixelRoundToJsonValue(); 1029 jsonValue = JsonUtil::ParseJsonString(res); 1030 ASSERT_NE(jsonValue, nullptr); 1031 EXPECT_EQ(jsonValue->GetString("top"), VALUE); 1032 1033 layoutProperty->pixelRoundFlag_ = static_cast<uint16_t>(PixelRoundPolicy::FORCE_CEIL_END); 1034 res = layoutProperty->PixelRoundToJsonValue(); 1035 jsonValue = JsonUtil::ParseJsonString(res); 1036 ASSERT_NE(jsonValue, nullptr); 1037 EXPECT_EQ(jsonValue->GetString("end"), VALUE); 1038 1039 layoutProperty->pixelRoundFlag_ = static_cast<uint16_t>(PixelRoundPolicy::FORCE_CEIL_BOTTOM); 1040 res = layoutProperty->PixelRoundToJsonValue(); 1041 jsonValue = JsonUtil::ParseJsonString(res); 1042 ASSERT_NE(jsonValue, nullptr); 1043 EXPECT_EQ(jsonValue->GetString("bottom"), VALUE); 1044 } 1045 1046 /** 1047 * @tc.name: CheckLocalizedBorderImageSlice004 1048 * @tc.desc: Test CheckLocalizedBorderImageSlice when Api is 12 and 14 1049 * @tc.type: FUNC 1050 */ 1051 HWTEST_F(LayoutPropertyTestNgTwo, CheckLocalizedBorderImageSlice004, TestSize.Level1) 1052 { 1053 auto layoutProperty = AceType::MakeRefPtr<LayoutProperty>(); 1054 auto frameNodeHost = FrameNode::CreateFrameNode("host", 1, AceType::MakeRefPtr<Pattern>(), true); 1055 layoutProperty->SetHost(frameNodeHost); 1056 1057 auto renderContext = frameNodeHost->GetRenderContext(); 1058 ASSERT_NE(renderContext, nullptr); 1059 auto borderImage = AceType::MakeRefPtr<BorderImage>(); 1060 auto sliceDimension = Dimension(5.0); 1061 auto widthDimension = Dimension(5.0); 1062 int32_t settingApiVersion = 12; 1063 AceApplicationInfo::GetInstance().SetApiTargetVersion(settingApiVersion); 1064 borderImage->SetEdgeSlice(BorderImageDirection::LEFT, sliceDimension); 1065 borderImage->SetEdgeWidth(BorderImageDirection::START, widthDimension); 1066 renderContext->UpdateBorderImage(borderImage); 1067 1068 auto textDirection = TextDirection::RTL; 1069 layoutProperty->CheckLocalizedBorderImageSlice(textDirection); 1070 EXPECT_EQ(borderImage->GetBorderImageEdge(BorderImageDirection::RIGHT).GetBorderImageSlice(), Dimension(0.0)); 1071 1072 settingApiVersion = 14; 1073 AceApplicationInfo::GetInstance().SetApiTargetVersion(settingApiVersion); 1074 auto borderImage1 = AceType::MakeRefPtr<BorderImage>(); 1075 borderImage1->SetEdgeSlice(BorderImageDirection::LEFT, sliceDimension); 1076 borderImage1->SetEdgeWidth(BorderImageDirection::START, widthDimension); 1077 renderContext->UpdateBorderImage(borderImage1); 1078 1079 layoutProperty->CheckLocalizedBorderImageSlice(textDirection); 1080 EXPECT_EQ(borderImage1->GetBorderImageEdge(BorderImageDirection::LEFT).GetBorderImageSlice(), sliceDimension); 1081 } 1082 1083 /** 1084 * @tc.name: CheckLocalizedBorderImageWidth004 1085 * @tc.desc: Test CheckLocalizedBorderImageWidth when Api is 12 and 14 1086 * @tc.type: FUNC 1087 */ 1088 HWTEST_F(LayoutPropertyTestNgTwo, CheckLocalizedBorderImageWidth004, TestSize.Level1) 1089 { 1090 auto layoutProperty = AceType::MakeRefPtr<LayoutProperty>(); 1091 auto frameNodeHost = FrameNode::CreateFrameNode("host", 1, AceType::MakeRefPtr<Pattern>(), true); 1092 layoutProperty->SetHost(frameNodeHost); 1093 1094 auto renderContext = frameNodeHost->GetRenderContext(); 1095 ASSERT_NE(renderContext, nullptr); 1096 auto borderImage = AceType::MakeRefPtr<BorderImage>(); 1097 auto sliceDimension = Dimension(5.0); 1098 auto widthDimension = Dimension(5.0); 1099 int32_t settingApiVersion = 12; 1100 AceApplicationInfo::GetInstance().SetApiTargetVersion(settingApiVersion); 1101 borderImage->SetEdgeSlice(BorderImageDirection::START, sliceDimension); 1102 borderImage->SetEdgeWidth(BorderImageDirection::LEFT, widthDimension); 1103 renderContext->UpdateBorderImage(borderImage); 1104 1105 auto textDirection = TextDirection::RTL; 1106 layoutProperty->CheckLocalizedBorderImageWidth(textDirection); 1107 EXPECT_EQ(borderImage->GetBorderImageEdge(BorderImageDirection::RIGHT).GetBorderImageWidth(), Dimension(0.0)); 1108 1109 settingApiVersion = 14; 1110 AceApplicationInfo::GetInstance().SetApiTargetVersion(settingApiVersion); 1111 auto borderImage1 = AceType::MakeRefPtr<BorderImage>(); 1112 borderImage1->SetEdgeSlice(BorderImageDirection::START, sliceDimension); 1113 borderImage1->SetEdgeWidth(BorderImageDirection::LEFT, widthDimension); 1114 renderContext->UpdateBorderImage(borderImage); 1115 layoutProperty->CheckLocalizedBorderImageWidth(textDirection); 1116 EXPECT_EQ(borderImage1->GetBorderImageEdge(BorderImageDirection::LEFT).GetBorderImageWidth(), widthDimension); 1117 } 1118 1119 /** 1120 * @tc.name: CheckLocalizedBorderImageOutset004 1121 * @tc.desc: Test CheckLocalizedBorderImageOutset when Api is 12 and 14 1122 * @tc.type: FUNC 1123 */ 1124 HWTEST_F(LayoutPropertyTestNgTwo, CheckLocalizedBorderImageOutset004, TestSize.Level1) 1125 { 1126 auto layoutProperty = AceType::MakeRefPtr<LayoutProperty>(); 1127 auto frameNodeHost = FrameNode::CreateFrameNode("host", 1, AceType::MakeRefPtr<Pattern>(), true); 1128 layoutProperty->SetHost(frameNodeHost); 1129 1130 auto renderContext = frameNodeHost->GetRenderContext(); 1131 ASSERT_NE(renderContext, nullptr); 1132 auto borderImage = AceType::MakeRefPtr<BorderImage>(); 1133 auto outsetDimension = Dimension(5.0); 1134 auto widthDimension = Dimension(5.0); 1135 int32_t settingApiVersion = 12; 1136 AceApplicationInfo::GetInstance().SetApiTargetVersion(settingApiVersion); 1137 borderImage->SetEdgeOutset(BorderImageDirection::LEFT, outsetDimension); 1138 borderImage->SetEdgeWidth(BorderImageDirection::START, widthDimension); 1139 renderContext->UpdateBorderImage(borderImage); 1140 1141 auto textDirection = TextDirection::RTL; 1142 layoutProperty->CheckLocalizedBorderImageOutset(textDirection); 1143 EXPECT_EQ(borderImage->GetBorderImageEdge(BorderImageDirection::RIGHT).GetBorderImageOutset(), Dimension(0.0)); 1144 1145 settingApiVersion = 14; 1146 AceApplicationInfo::GetInstance().SetApiTargetVersion(settingApiVersion); 1147 renderContext->UpdateBorderImage(borderImage); 1148 auto borderImage1 = AceType::MakeRefPtr<BorderImage>(); 1149 borderImage1->SetEdgeOutset(BorderImageDirection::LEFT, outsetDimension); 1150 borderImage1->SetEdgeWidth(BorderImageDirection::START, widthDimension); 1151 layoutProperty->CheckLocalizedBorderImageOutset(textDirection); 1152 EXPECT_EQ(borderImage1->GetBorderImageEdge(BorderImageDirection::LEFT).GetBorderImageOutset(), outsetDimension); 1153 } 1154 } 1155