1 /* 2 * Copyright (c) 2023 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 #include "gmock/gmock.h" 16 #include "gtest/gtest.h" 17 18 #include "base/utils/utils.h" 19 #define protected public 20 #define private public 21 #include "test/mock/core/render/mock_canvas_image.h" 22 #include "test/mock/core/rosen/mock_canvas.h" 23 24 #include "base/geometry/ng/point_t.h" 25 #include "core/components/common/properties/paint_state.h" 26 #include "core/components_ng/pattern/image/image_paint_method.h" 27 #include "core/components_ng/render/adapter/pixelmap_image.h" 28 #include "core/components_ng/render/adapter/svg_canvas_image.h" 29 #include "core/components_ng/render/canvas_image.h" 30 #include "core/components_ng/render/drawing_prop_convertor.h" 31 #include "core/components_ng/render/image_painter.h" 32 #include "core/pipeline_ng/pipeline_context.h" 33 34 #undef private 35 #undef protected 36 37 using namespace testing; 38 using namespace testing::ext; 39 40 namespace OHOS::Ace { 41 namespace { 42 Testing::MockCanvas testingCanvas; 43 44 const NG::OffsetF& OFFSETF { 1, 1 }; 45 const NG::SizeF& SIZE { 10, 10 }; 46 47 const NG::OffsetF& OFFSETF1 { 0, 0 }; 48 const NG::SizeF& SIZE1 { 0, 0 }; 49 50 const NG::RectF& CONTENTRECT { 1, 1, 1, 1 }; 51 52 NG::SizeF rawpicsize { 1, 1 }; 53 NG::SizeF dstsize { 1, 1 }; 54 55 NG::SizeF boxPaintSize_ { 1, 1 }; 56 NG::SizeF srcSize { 1, 1 }; 57 58 NG::RectF srcRect_ { 2, 1, 2, 1 }; 59 NG::RectF dstRect_ { 1, 1, 1, 1 }; 60 61 NG::PointF pointF_ { 10.0, 10.0 }; 62 } // namespace 63 64 class ImagePainterTestNg : public testing::Test {}; 65 66 /** 67 * @tc.name: ImagePainterTestNg_DrawImage1 68 * @tc.desc: Test cast to CirclePainterTestNg 69 * @tc.type: FUNC 70 */ 71 HWTEST_F(ImagePainterTestNg, ImagePainterTestNg_DrawImage1, TestSize.Level1) 72 { 73 /** 74 * @tc.steps1: build a imagePainter and imagePaintConfig object. 75 */ 76 EXPECT_CALL(testingCanvas, AttachBrush(_)).WillRepeatedly(ReturnRef(testingCanvas)); 77 EXPECT_CALL(testingCanvas, DetachBrush()).WillRepeatedly(ReturnRef(testingCanvas)); 78 EXPECT_CALL(testingCanvas, AttachPen(_)).WillRepeatedly(ReturnRef(testingCanvas)); 79 EXPECT_CALL(testingCanvas, DetachPen()).WillRepeatedly(ReturnRef(testingCanvas)); 80 RefPtr<NG::CanvasImage> canvasImage; 81 NG::ImagePainter imagePainter(canvasImage); 82 NG::ImagePaintConfig imagePaintConfig; 83 84 /** 85 * @tc.steps2: callback DrawImage. 86 * @tc.expected: expect imagePainter.canvasImage_ is null. 87 */ 88 imagePainter.DrawImage(testingCanvas, OFFSETF, SIZE); 89 EXPECT_EQ(imagePainter.canvasImage_, nullptr); 90 91 /** 92 * @tc.steps3: build a cavans image object. 93 */ 94 imagePainter.canvasImage_ = AceType::MakeRefPtr<NG::MockCanvasImage>(); 95 imagePainter.canvasImage_->paintConfig_ = std::make_unique<NG::ImagePaintConfig>(); 96 97 /** 98 * @tc.steps4: callback DrawImage. 99 * @tc.expected: expect imagePainter.canvasImage_ is not null. 100 */ 101 imagePainter.DrawImage(testingCanvas, OFFSETF, SIZE); 102 ASSERT_NE(imagePainter.canvasImage_, nullptr); 103 104 imagePaintConfig.isSvg_ = true; 105 imagePainter.canvasImage_->paintConfig_ = std::make_unique<NG::ImagePaintConfig>(imagePaintConfig); 106 imagePainter.DrawImage(testingCanvas, OFFSETF, SIZE); 107 108 /** 109 * @tc.steps5: Assign values to call parameters. 110 */ 111 imagePaintConfig.imageRepeat_ = ImageRepeat::REPEAT; 112 imagePaintConfig.isSvg_ = false; 113 imagePainter.canvasImage_->paintConfig_ = std::make_unique<NG::ImagePaintConfig>(imagePaintConfig); 114 115 /** 116 * @tc.steps6: callback DrawImage. 117 * @tc.expected: expect contentRect.Width and contentRect.Height are 1. 118 */ 119 imagePainter.DrawImage(testingCanvas, OFFSETF, SIZE); 120 EXPECT_EQ(CONTENTRECT.Width(), 1); 121 EXPECT_EQ(CONTENTRECT.Height(), 1); 122 123 /** 124 * @tc.steps7: callback DrawImage. 125 * @tc.expected: expect imagePainter.canvasImage_ is not null 126 */ 127 ASSERT_NE(imagePainter.canvasImage_->paintConfig_, nullptr); 128 std::vector<ObscuredReasons> reasons; 129 reasons.emplace_back(static_cast<ObscuredReasons>(0)); 130 imagePainter.canvasImage_->paintConfig_->obscuredReasons_ = reasons; 131 imagePainter.DrawImage(testingCanvas, OFFSETF, SIZE); 132 EXPECT_NE(imagePainter.canvasImage_, nullptr); 133 } 134 135 /** 136 * @tc.name: ImagePainterTestNg_DrawObscuration001 137 * @tc.desc: Test DrawObscuration 138 * @tc.type: FUNC 139 */ 140 HWTEST_F(ImagePainterTestNg, ImagePainterTestNg_DrawObscuration001, TestSize.Level1) 141 { 142 /** 143 * @tc.steps1: create a imagePainter and imagePaintConfig object. 144 */ 145 RefPtr<NG::CanvasImage> canvasImage; 146 NG::ImagePainter imagePainter(canvasImage); 147 NG::ImagePaintConfig imagePaintConfig; 148 /** 149 * @tc.steps2: build a pixelMapImage object. 150 */ 151 imagePainter.canvasImage_ = AceType::MakeRefPtr<NG::MockCanvasImage>(); 152 imagePainter.canvasImage_->paintConfig_ = std::make_unique<NG::ImagePaintConfig>(); 153 ASSERT_NE(imagePainter.canvasImage_, nullptr); 154 ASSERT_NE(imagePainter.canvasImage_->paintConfig_, nullptr); 155 /** 156 * @tc.steps3: call DrawObscuration. 157 * @tc.expected: expect canvasImage_.borderRadiusXY_ is null 158 */ 159 imagePainter.DrawObscuration(testingCanvas, OFFSETF, SIZE); 160 imagePainter.canvasImage_->paintConfig_->isSvg_ = true; 161 imagePainter.DrawObscuration(testingCanvas, OFFSETF, SIZE); 162 EXPECT_EQ(imagePainter.canvasImage_->paintConfig_->borderRadiusXY_, nullptr); 163 /** 164 * @tc.steps4: set radiusXY to canvasImage_.borderRadiusXY_ and call DrawObscuration 165 * @tc.expected: expect canvasImage_.borderRadiusXY_ is not null 166 */ 167 NG::BorderRadiusArray radiusXY = { pointF_, pointF_, pointF_, pointF_ }; 168 imagePainter.canvasImage_->paintConfig_->borderRadiusXY_ = std::make_shared<NG::BorderRadiusArray>(radiusXY); 169 imagePainter.DrawObscuration(testingCanvas, OFFSETF, SIZE); 170 EXPECT_NE(imagePainter.canvasImage_->paintConfig_->borderRadiusXY_, nullptr); 171 } 172 173 /** 174 * @tc.name: ImagePainterTestNg_DrawSVGImage2 175 * @tc.desc: Test cast to CirclePainterTestNg 176 * @tc.type: FUNC 177 */ 178 HWTEST_F(ImagePainterTestNg, ImagePainterTestNg_DrawSVGImage2, TestSize.Level1) 179 { 180 /** 181 * @tc.steps1: build a imagePainter and imagePaintConfig object. 182 */ 183 RefPtr<NG::CanvasImage> canvasImage; 184 NG::ImagePainter imagePainter(canvasImage); 185 NG::ImagePaintConfig imagePaintConfig; 186 187 /** 188 * @tc.steps2: callback DrawImage. 189 * @tc.expected: expect imagePainter.canvasImage_ is null. 190 */ 191 imagePainter.DrawSVGImage(testingCanvas, OFFSETF, SIZE); 192 EXPECT_EQ(imagePainter.canvasImage_, nullptr); 193 194 /** 195 * @tc.steps3: build a pixelMapImage object. 196 */ 197 imagePainter.canvasImage_ = AceType::MakeRefPtr<NG::MockCanvasImage>(); 198 imagePainter.canvasImage_->paintConfig_ = std::make_unique<NG::ImagePaintConfig>(); 199 /** 200 * @tc.steps4: Assign values to call parameters. 201 */ 202 imagePaintConfig.flipHorizontally_ = true; 203 imagePainter.canvasImage_->paintConfig_ = std::make_unique<NG::ImagePaintConfig>(imagePaintConfig); 204 205 /** 206 * @tc.steps5: callback DrawImage. 207 * @tc.expected: expect OFFSETF.GetX() is 1 and test is 0. 208 */ 209 imagePainter.DrawSVGImage(testingCanvas, OFFSETF, SIZE); 210 EXPECT_EQ(OFFSETF.GetX(), 1); 211 auto test = imagePainter.canvasImage_->GetPaintConfig().dstRect_.Width(); 212 EXPECT_EQ(test, 0); 213 } 214 215 /** 216 * @tc.name: ImagePainterTestNg_DrawStaticImage3 217 * @tc.desc: Test cast to CirclePainterTestNg 218 * @tc.type: FUNC 219 */ 220 HWTEST_F(ImagePainterTestNg, ImagePainterTestNg_DrawStaticImage3, TestSize.Level1) 221 { 222 /** 223 * @tc.steps1: build a imagePainter and imagePaintConfig object. 224 */ 225 RefPtr<NG::CanvasImage> canvasImage; 226 NG::ImagePainter imagePainter(canvasImage); 227 NG::ImagePaintConfig imagePaintConfig; 228 229 /** 230 * @tc.steps2: callback DrawImage. 231 * @tc.expected: expect imagePainter.canvasImage_ is null. 232 */ 233 imagePainter.DrawStaticImage(testingCanvas, OFFSETF, SIZE); 234 EXPECT_EQ(imagePainter.canvasImage_, nullptr); 235 236 /** 237 * @tc.steps3: build a pixelMapImage object. 238 */ 239 imagePainter.canvasImage_ = AceType::MakeRefPtr<NG::MockCanvasImage>(); 240 imagePainter.canvasImage_->paintConfig_ = std::make_unique<NG::ImagePaintConfig>(); 241 /** 242 * @tc.steps4: Assign values to call parameters. 243 */ 244 imagePaintConfig.renderMode_ = ImageRenderMode::TEMPLATE; 245 imagePainter.canvasImage_->paintConfig_ = std::make_unique<NG::ImagePaintConfig>(imagePaintConfig); 246 247 /** 248 * @tc.steps5: callback DrawStaticImage. 249 * @tc.expected: expect OFFSETF.GetX() and OFFSETF.GetY() are 1. 250 */ 251 imagePainter.DrawStaticImage(testingCanvas, OFFSETF, SIZE); 252 EXPECT_EQ(OFFSETF.GetX(), 1); 253 EXPECT_EQ(OFFSETF.GetY(), 1); 254 255 /** 256 * @tc.steps6: Assign values to call parameters. 257 */ 258 imagePaintConfig.flipHorizontally_ = true; 259 imagePainter.canvasImage_->paintConfig_ = std::make_unique<NG::ImagePaintConfig>(imagePaintConfig); 260 261 /** 262 * @tc.steps7: callback DrawStaticImage. 263 * @tc.expected: expect OFFSETF.GetX() is 1 and test is 0. 264 */ 265 imagePainter.DrawStaticImage(testingCanvas, OFFSETF, SIZE); 266 EXPECT_EQ(OFFSETF.GetX(), 1); 267 auto test = imagePainter.canvasImage_->GetPaintConfig().dstRect_.Width(); 268 EXPECT_EQ(test, 0); 269 } 270 271 /** 272 * @tc.name: ImagePainterTestNg_FlipHorizontal4 273 * @tc.desc: Test cast to CirclePainterTestNg 274 * @tc.type: FUNC 275 */ 276 HWTEST_F(ImagePainterTestNg, ImagePainterTestNg_FlipHorizontal4, TestSize.Level1) 277 { 278 /** 279 * @tc.steps1: build a imagePainter object. 280 */ 281 RefPtr<NG::CanvasImage> canvasImage; 282 NG::ImagePainter imagePainter(canvasImage); 283 284 /** 285 * @tc.steps2: callback DrawImage. 286 */ 287 imagePainter.FlipHorizontal(testingCanvas, SIZE); 288 } 289 290 /** 291 * @tc.name: ImagePainterTestNg_DrawImageWithRepeat5 292 * @tc.desc: Test cast to CirclePainterTestNg 293 * @tc.type: FUNC 294 */ 295 HWTEST_F(ImagePainterTestNg, ImagePainterTestNg_DrawImageWithRepeat5, TestSize.Level1) 296 { 297 /** 298 * @tc.steps1: build a imagePainter object. 299 */ 300 RefPtr<NG::CanvasImage> canvasImage; 301 NG::ImagePainter imagePainter(canvasImage); 302 NG::ImagePaintConfig imagePaintConfig; 303 304 /** 305 * @tc.steps2 build a pixelMapImage object. 306 */ 307 imagePainter.canvasImage_ = AceType::MakeRefPtr<NG::MockCanvasImage>(); 308 imagePainter.canvasImage_->paintConfig_ = std::make_unique<NG::ImagePaintConfig>(); 309 310 /** 311 * @tc.steps3callback DrawImageWithRepeat. 312 * @tc.expected: expect CONTENTRECT.Width() and CONTENTRECT.Height() is 0. 313 */ 314 imagePainter.DrawImageWithRepeat(testingCanvas, CONTENTRECT); 315 EXPECT_EQ(CONTENTRECT.Width(), 1); 316 EXPECT_EQ(CONTENTRECT.Height(), 1); 317 318 /** 319 * @tc.steps4: Assign values to call parameters. 320 */ 321 imagePaintConfig.imageRepeat_ = ImageRepeat::REPEAT; 322 imagePaintConfig.dstRect_.width_ = 1; 323 imagePaintConfig.dstRect_.height_ = 1; 324 imagePainter.canvasImage_->paintConfig_ = std::make_unique<NG::ImagePaintConfig>(imagePaintConfig); 325 326 /** 327 * @tc.steps5 callback DrawImageWithRepeat. 328 * @tc.expected: expect CONTENTRECT.GetOffset().GetX and CONTENTRECT.GetOffset().GetY is 0. 329 */ 330 imagePainter.DrawImageWithRepeat(testingCanvas, CONTENTRECT); 331 EXPECT_EQ(CONTENTRECT.GetOffset().GetX(), 1); 332 EXPECT_EQ(CONTENTRECT.GetOffset().GetY(), 1); 333 334 /** 335 * @tc.steps6: Assign values to call parameters. 336 */ 337 imagePaintConfig.imageRepeat_ = ImageRepeat::REPEAT_X; 338 imagePaintConfig.imageRepeat_ = ImageRepeat::REPEAT_Y; 339 imagePaintConfig.dstRect_.width_ = 1; 340 imagePaintConfig.dstRect_.height_ = 1; 341 imagePainter.canvasImage_->paintConfig_ = std::make_unique<NG::ImagePaintConfig>(imagePaintConfig); 342 imagePainter.DrawImageWithRepeat(testingCanvas, CONTENTRECT); 343 } 344 345 /** 346 * @tc.name: ImagePainterTestNg_ApplyImageFit6 347 * @tc.desc: Test cast to CirclePainterTestNg 348 * @tc.type: FUNC 349 */ 350 HWTEST_F(ImagePainterTestNg, ImagePainterTestNg_ApplyImageFit6, TestSize.Level1) 351 { 352 /** 353 * @tc.steps1: build a imagePainter object. 354 */ 355 RefPtr<NG::CanvasImage> canvasImage; 356 NG::ImagePainter imagePainter(canvasImage); 357 NG::RectF srcRect_; 358 NG::RectF dstRect_; 359 360 /** 361 * @tc.steps2: callback ApplyImageFit. 362 * @tc.expected: expect viewScale is 1. 363 */ 364 imagePainter.ApplyImageFit(ImageFit::FILL, rawpicsize, dstsize, srcRect_, dstRect_); 365 auto context = PipelineContext::GetCurrentContext(); 366 float viewScale = context ? context->GetViewScale() : 1.0; 367 EXPECT_EQ(viewScale, 1); 368 369 /** 370 * @tc.steps3: callback ApplyImageFit when ImageFit::NONE. 371 * @tc.expected: expect testsize.GetX() and testsize.GetY() are 1. 372 */ 373 imagePainter.ApplyImageFit(ImageFit::NONE, rawpicsize, dstsize, srcRect_, dstRect_); 374 NG::SizeF srcSize(std::min(dstsize.Width(), rawpicsize.Width()), std::min(dstsize.Height(), rawpicsize.Height())); 375 auto testSize = Alignment::GetAlignPosition(dstsize, srcSize, Alignment::CENTER); 376 EXPECT_EQ(testSize.GetX(), 0); 377 EXPECT_EQ(testSize.GetY(), 0); 378 379 /** 380 * @tc.steps4: callback ApplyImageFit when ImageFit::COVER. 381 * @tc.expected: expect testsize1.GetX() and testsize1.GetY() are 1. 382 */ 383 imagePainter.ApplyImageFit(ImageFit::COVER, rawpicsize, dstsize, srcRect_, dstRect_); 384 auto testSize1 = Alignment::GetAlignPosition(rawpicsize, srcRect_.GetSize(), Alignment::CENTER); 385 EXPECT_EQ(testSize1.GetX(), 0); 386 EXPECT_EQ(testSize1.GetY(), 0); 387 388 /** 389 * @tc.steps5: callback ApplyImageFit when ImageFit::FITWIDTH. 390 * @tc.expected: expect testsize2.GetX() and testsize2.GetY() are 1. 391 */ 392 imagePainter.ApplyImageFit(ImageFit::FITWIDTH, rawpicsize, dstsize, srcRect_, dstRect_); 393 auto testSize2 = Alignment::GetAlignPosition(rawpicsize, srcRect_.GetSize(), Alignment::CENTER); 394 EXPECT_EQ(testSize2.GetX(), 0); 395 EXPECT_EQ(testSize2.GetY(), 0); 396 397 /** 398 * @tc.steps6: callback ApplyImageFit when ImageFit::FITHEIGHT. 399 * @tc.expected: expect testsize3.GetX() and testsize3.GetY() are 1. 400 */ 401 imagePainter.ApplyImageFit(ImageFit::FITHEIGHT, rawpicsize, dstsize, srcRect_, dstRect_); 402 auto testSize3 = Alignment::GetAlignPosition(dstsize, dstRect_.GetSize(), Alignment::CENTER); 403 EXPECT_EQ(testSize3.GetX(), 0); 404 EXPECT_EQ(testSize3.GetY(), 0); 405 406 /** 407 * @tc.steps7: callback ApplyImageFit when ImageFit::SCALE_DOWN. 408 * @tc.expected: expect testsize4.GetX() and testsize4.GetY() are 1. 409 */ 410 imagePainter.ApplyImageFit(ImageFit::SCALE_DOWN, rawpicsize, dstsize, srcRect_, dstRect_); 411 NG::SizeF srcSize1(std::min(dstsize.Width(), rawpicsize.Width()), std::min(dstsize.Height(), rawpicsize.Height())); 412 auto testSize4 = Alignment::GetAlignPosition(dstsize, srcSize1, Alignment::CENTER); 413 EXPECT_EQ(testSize4.GetX(), 0); 414 EXPECT_EQ(testSize4.GetY(), 0); 415 416 /** 417 * @tc.steps8: callback ApplyImageFit when ImageFit::CONTAIN. 418 * @tc.expected: expect testsize8.GetX() and testsize8.GetY() are 1. 419 */ 420 imagePainter.ApplyImageFit(ImageFit::CONTAIN, rawpicsize, dstsize, srcRect_, dstRect_); 421 auto testSize5 = Alignment::GetAlignPosition(dstsize, dstRect_.GetSize(), Alignment::CENTER); 422 EXPECT_EQ(testSize5.GetX(), 0); 423 EXPECT_EQ(testSize5.GetY(), 0); 424 425 /** 426 * @tc.steps9: callback ApplyImageFit when ImageFit::COVER_TOP_LEFT. 427 * @tc.expected: expect testsize6.GetX() and testsize6.GetY() are 1. 428 */ 429 imagePainter.ApplyImageFit(ImageFit::COVER_TOP_LEFT, rawpicsize, dstsize, srcRect_, dstRect_); 430 auto testSize6 = Alignment::GetAlignPosition(dstsize, dstRect_.GetSize(), Alignment::CENTER); 431 EXPECT_EQ(testSize6.GetX(), 0); 432 EXPECT_EQ(testSize6.GetY(), 0); 433 } 434 435 /** 436 * @tc.name: ImagePainterTestNg_ImagePainter7 437 * @tc.desc: Test cast to CirclePainterTestNg 438 * @tc.type: FUNC 439 */ 440 HWTEST_F(ImagePainterTestNg, ImagePainterTestNg_ImagePainter7, TestSize.Level1) 441 { 442 /** 443 * @tc.steps1: build a imagePainter object. 444 */ 445 RefPtr<NG::CanvasImage> canvasImage; 446 NG::ImagePainter imagePainter(canvasImage); 447 const NG::SizeF boxPaintSize_; 448 const NG::SizeF imageRenderSize_; 449 BackgroundImagePosition backgroundImagePosition( 450 BackgroundImagePositionType::PERCENT, 1, BackgroundImagePositionType::PERCENT, 1); 451 std::optional<BackgroundImagePosition> bgImgPositionOpt = backgroundImagePosition; 452 453 /** 454 * @tc.steps2: callback CalculateBgImagePosition when BackgroundImagePositionType::PERCENT. 455 * @tc.expected: expect offset.GetX() and offset.GetY() are 0. 456 */ 457 auto offset = imagePainter.CalculateBgImagePosition(boxPaintSize_, imageRenderSize_, bgImgPositionOpt); 458 EXPECT_EQ(offset.GetX(), 0); 459 EXPECT_EQ(offset.GetY(), 0); 460 461 /** 462 * @tc.steps3: callback CalculateBgImagePosition when BackgroundImagePositionType::PX. 463 * @tc.expected: expect offset.GetX() and offset.GetY() are 0. 464 */ 465 BackgroundImagePosition backgroundImagePosition1( 466 BackgroundImagePositionType::PX, 1, BackgroundImagePositionType::PX, 1); 467 std::optional<BackgroundImagePosition> bgImgPositionOpt1 = backgroundImagePosition1; 468 auto offset1 = imagePainter.CalculateBgImagePosition(boxPaintSize_, imageRenderSize_, bgImgPositionOpt1); 469 EXPECT_EQ(offset1.GetX(), 1); 470 EXPECT_EQ(offset1.GetY(), 1); 471 472 /** 473 * @tc.steps3: callback CalculateBgImagePosition and reset bgImgPositionOpt. 474 * @tc.expected: expect offset.GetX() and offset.GetY() are 0. 475 */ 476 BackgroundImagePosition backgroundImagePosition2( 477 BackgroundImagePositionType::PX, 1, BackgroundImagePositionType::PX, 1); 478 std::optional<BackgroundImagePosition> bgImgPositionOpt2 = backgroundImagePosition2; 479 bgImgPositionOpt2.reset(); 480 auto offset2 = imagePainter.CalculateBgImagePosition(boxPaintSize_, imageRenderSize_, bgImgPositionOpt2); 481 EXPECT_EQ(offset2.GetX(), 0); 482 EXPECT_EQ(offset2.GetY(), 0); 483 } 484 485 /** 486 * @tc.name: ImagePainterTestNg_CalculateBgImageSize8 487 * @tc.desc: Test cast to CirclePainterTestNg 488 * @tc.type: FUNC 489 */ 490 HWTEST_F(ImagePainterTestNg, ImagePainterTestNg_CalculateBgImageSize8, TestSize.Level1) 491 { 492 /** 493 * @tc.steps1: creat a bgImageSizeOpt std::optiona. 494 */ 495 BackgroundImageSize backgroundImageSize1(BackgroundImageSizeType::AUTO, 2, BackgroundImageSizeType::AUTO, 2); 496 std::optional<BackgroundImageSize> bgImageSizeOpt1 = backgroundImageSize1; 497 498 /** 499 * @tc.steps2: callback CalculateBgImageSize when valueX_ is 2. 500 * @tc.expected: expect sizeRet.Width() and sizeRet.Height() are 2. 501 */ 502 auto sizeRet = NG::ImagePainter::CalculateBgImageSize(boxPaintSize_, srcSize, bgImageSizeOpt1); 503 EXPECT_EQ(sizeRet.Width(), 1); 504 EXPECT_EQ(sizeRet.Height(), 1); 505 506 /** 507 * @tc.steps3: callback CalculateBgImageSize when valueX_ is -1. 508 * @tc.expected: expect sizeRet.Width() and sizeRet.Height() are -1. 509 */ 510 BackgroundImageSize backgroundImageSize2(BackgroundImageSizeType::LENGTH, -1, BackgroundImageSizeType::LENGTH, -1); 511 std::optional<BackgroundImageSize> bgImageSizeOpt2 = backgroundImageSize2; 512 auto sizeRet1 = NG::ImagePainter::CalculateBgImageSize(boxPaintSize_, srcSize, bgImageSizeOpt2); 513 EXPECT_EQ(sizeRet1.Width(), -1); 514 EXPECT_EQ(sizeRet1.Height(), -1); 515 516 /** 517 * @tc.steps4: callback CalculateBgImageSize when valueX_ is 1 and valueY is 11. 518 * @tc.expected: expect sizeRet.Width() and sizeRet.Height() are 2. 519 */ 520 BackgroundImageSize backgroundImageSize3(BackgroundImageSizeType::LENGTH, 1, BackgroundImageSizeType::LENGTH, -1); 521 std::optional<BackgroundImageSize> bgImageSizeOpt3 = backgroundImageSize3; 522 auto sizeRet2 = NG::ImagePainter::CalculateBgImageSize(boxPaintSize_, srcSize, bgImageSizeOpt3); 523 EXPECT_EQ(sizeRet2.Width(), 1); 524 EXPECT_EQ(sizeRet2.Height(), 1); 525 526 /** 527 * @tc.steps5: callback CalculateBgImageSize when valueX_ is -1 and valueY is -1. 528 * @tc.expected: expect sizeRet.Width() and sizeRet.Height() are -1. 529 */ 530 srcSize = { -1, -1 }; 531 boxPaintSize_ = { -1, -1 }; 532 BackgroundImageSize backgroundImageSize4(BackgroundImageSizeType::LENGTH, 1, BackgroundImageSizeType::LENGTH, -1); 533 std::optional<BackgroundImageSize> bgImageSizeOpt4 = backgroundImageSize4; 534 bgImageSizeOpt4.reset(); 535 auto sizeRet3 = NG::ImagePainter::CalculateBgImageSize(boxPaintSize_, srcSize, bgImageSizeOpt4); 536 EXPECT_EQ(sizeRet3.Width(), -1); 537 EXPECT_EQ(sizeRet3.Height(), -1); 538 } 539 540 /** 541 * @tc.name: ImagePainterTestNg_CalculateBgWidth9 542 * @tc.desc: Test cast to CirclePainterTestNg 543 * @tc.type: FUNC 544 */ 545 HWTEST_F(ImagePainterTestNg, ImagePainterTestNg_CalculateBgWidth9, TestSize.Level1) 546 { 547 /** 548 * @tc.steps1: creat a backgroundImageSize object. 549 */ 550 BackgroundImageSize backgroundImageSize(BackgroundImageSizeType::AUTO, 2, BackgroundImageSizeType::AUTO, 2); 551 552 /** 553 * @tc.steps2: creat for loop change BackgroundImageSizeTypeX and callback CalculateBgImageSize. 554 * @tc.expected: expect offset.GetX() and offset.GetY() are -1. 555 */ 556 for (int32_t index = 0; index <= 4; index++) { 557 backgroundImageSize.typeX_ = static_cast<BackgroundImageSizeType>(index); 558 const std::optional<BackgroundImageSize>& bgImageSizeOpt = backgroundImageSize; 559 NG::ImagePainter::CalculateBgImageSize(boxPaintSize_, srcSize, bgImageSizeOpt); 560 switch (backgroundImageSize.typeX_) { 561 case BackgroundImageSizeType::COVER: 562 EXPECT_EQ(srcSize.Width(), -1); 563 break; 564 case BackgroundImageSizeType::CONTAIN: 565 EXPECT_EQ(srcSize.Width(), -1); 566 break; 567 case BackgroundImageSizeType::LENGTH: 568 EXPECT_EQ(srcSize.Width(), -1); 569 break; 570 case BackgroundImageSizeType::PERCENT: 571 EXPECT_EQ(srcSize.Width(), -1); 572 break; 573 default: 574 break; 575 } 576 } 577 578 /** 579 * @tc.steps3: creat for loop change BackgroundImageSizeTypeY and callback CalculateBgImageSize. 580 * @tc.expected: expect offset.GetX() and offset.GetY() are -1. 581 */ 582 for (int32_t index = 0; index <= 4; index++) { 583 backgroundImageSize.typeY_ = static_cast<BackgroundImageSizeType>(index); 584 const std::optional<BackgroundImageSize>& bgImageSizeOpt = backgroundImageSize; 585 NG::ImagePainter::CalculateBgImageSize(boxPaintSize_, srcSize, bgImageSizeOpt); 586 switch (backgroundImageSize.typeY_) { 587 case BackgroundImageSizeType::COVER: 588 EXPECT_EQ(srcSize.Height(), -1); 589 break; 590 case BackgroundImageSizeType::CONTAIN: 591 EXPECT_EQ(srcSize.Height(), -1); 592 break; 593 case BackgroundImageSizeType::LENGTH: 594 EXPECT_EQ(srcSize.Height(), -1); 595 break; 596 case BackgroundImageSizeType::PERCENT: 597 EXPECT_EQ(srcSize.Height(), -1); 598 break; 599 default: 600 break; 601 } 602 } 603 } 604 605 /** 606 * @tc.name: ImagePainterTestNg_CalculateBgWidth10 607 * @tc.desc: Test cast to CirclePainterTestNg 608 * @tc.type: FUNC 609 */ 610 HWTEST_F(ImagePainterTestNg, ImagePainterTestNg_CalculateBgImageSize10, TestSize.Level1) 611 { 612 /** 613 * @tc.steps1: creat a bgImageSizeOpt1 and callback CalculateBgImageSize. 614 * @tc.expected: expect width1 is -2. 615 */ 616 srcSize = { 2, 1 }; 617 BackgroundImageSize backgroundImageSize1(BackgroundImageSizeType::COVER, 1, BackgroundImageSizeType::COVER, 1); 618 const std::optional<BackgroundImageSize>& bgImageSizeOpt1 = backgroundImageSize1; 619 NG::ImagePainter::CalculateBgImageSize(boxPaintSize_, srcSize, bgImageSizeOpt1); 620 auto width1 = srcSize.Width() * (boxPaintSize_.Height() / srcSize.Height()); 621 EXPECT_EQ(width1, -2); 622 623 /** 624 * @tc.steps2: creat a bgImageSizeOpt2 and callback CalculateBgImageSize. 625 * @tc.expected: expect width1 is 1. 626 */ 627 srcSize = { 2, 1 }; 628 BackgroundImageSize backgroundImageSize2(BackgroundImageSizeType::CONTAIN, 1, BackgroundImageSizeType::CONTAIN, 1); 629 const std::optional<BackgroundImageSize>& bgImageSizeOpt2 = backgroundImageSize2; 630 NG::ImagePainter::CalculateBgImageSize(boxPaintSize_, srcSize, bgImageSizeOpt2); 631 auto width2 = boxPaintSize_.Width(); 632 EXPECT_EQ(width2, -1); 633 } 634 635 /** 636 * @tc.name: ImagePainterTestNg_ApplyImageFit11 637 * @tc.desc: Test cast to CirclePainterTestNg 638 * @tc.type: FUNC 639 */ 640 HWTEST_F(ImagePainterTestNg, ImagePainterTestNg_ApplyImageFit11, TestSize.Level1) 641 { 642 /** 643 * @tc.steps1: build a imagePainter object. 644 */ 645 RefPtr<NG::CanvasImage> canvasImage; 646 NG::ImagePainter imagePainter(canvasImage); 647 rawpicsize = { 10, 1 }; 648 649 /** 650 * @tc.steps2: callback ApplyImageFit when ImageFit::COVER. 651 * @tc.expected: expect testsize1.GetX() is 4.5 and testsize1.GetY() is 0. 652 */ 653 imagePainter.ApplyImageFit(ImageFit::COVER, rawpicsize, dstsize, srcRect_, dstRect_); 654 auto testSize1 = Alignment::GetAlignPosition(rawpicsize, srcRect_.GetSize(), Alignment::CENTER); 655 EXPECT_EQ(testSize1.GetX(), 4.5); 656 EXPECT_EQ(testSize1.GetY(), 0); 657 658 /** 659 * @tc.steps3: callback ApplyImageFit when ImageFit::FITWIDTH. 660 * @tc.expected: expect testsize2.GetX() and testsize2.GetY() are 0. 661 */ 662 imagePainter.ApplyImageFit(ImageFit::FITWIDTH, rawpicsize, dstsize, srcRect_, dstRect_); 663 auto testSize2 = Alignment::GetAlignPosition(rawpicsize, srcRect_.GetSize(), Alignment::CENTER); 664 EXPECT_EQ(testSize2.GetX(), 0); 665 EXPECT_EQ(testSize2.GetY(), 0); 666 667 /** 668 * @tc.steps4: callback ApplyImageFit when ImageFit::FITHEIGHT. 669 * @tc.expected: expect testsize3.GetX() and testsize3.GetY() are 0. 670 */ 671 imagePainter.ApplyImageFit(ImageFit::FITHEIGHT, rawpicsize, dstsize, srcRect_, dstRect_); 672 auto testSize3 = Alignment::GetAlignPosition(dstsize, dstRect_.GetSize(), Alignment::CENTER); 673 EXPECT_EQ(testSize3.GetX(), 0); 674 EXPECT_EQ(testSize3.GetY(), 0); 675 676 /** 677 * @tc.steps5: callback ApplyImageFit when ImageFit::CONTAIN. 678 * @tc.expected: expect testsize8.GetX() is 0 and testsize8.GetY() are 0.45. 679 */ 680 imagePainter.ApplyImageFit(ImageFit::CONTAIN, rawpicsize, dstsize, srcRect_, dstRect_); 681 auto testSize4 = Alignment::GetAlignPosition(dstsize, dstRect_.GetSize(), Alignment::CENTER); 682 EXPECT_EQ(testSize4.GetX(), 0); 683 EXPECT_FLOAT_EQ(testSize4.GetY(), 0.45); 684 685 /** 686 * @tc.steps6: callback ApplyImageFit when ImageFit::CONTAIN. 687 * @tc.expected: expect testsize8.GetX() and testsize8.GetY() are 0. 688 */ 689 rawpicsize = { -1, -1 }; 690 imagePainter.ApplyImageFit(ImageFit::CONTAIN, rawpicsize, dstsize, srcRect_, dstRect_); 691 auto testSize5 = Alignment::GetAlignPosition(dstsize, dstRect_.GetSize(), Alignment::CENTER); 692 EXPECT_EQ(testSize5.GetX(), 0); 693 EXPECT_EQ(testSize5.GetY(), 0); 694 695 /** 696 * @tc.steps7: callback ApplyImageFit when ImageFit::COVER_TOP_LEFT. 697 * @tc.expected: expect testsize6.GetX() and testsize6.GetY() are 0. 698 */ 699 rawpicsize = { -1, -1 }; 700 imagePainter.ApplyImageFit(ImageFit::COVER_TOP_LEFT, rawpicsize, dstsize, srcRect_, dstRect_); 701 auto testSize6 = Alignment::GetAlignPosition(dstsize, dstRect_.GetSize(), Alignment::CENTER); 702 EXPECT_EQ(testSize6.GetX(), 0); 703 EXPECT_EQ(testSize6.GetY(), 0); 704 } 705 706 /** 707 * @tc.name: ImagePainterTestNg_DrawImage002 708 * @tc.desc: Test cast to DrawImage 709 * @tc.type: FUNC 710 */ 711 HWTEST_F(ImagePainterTestNg, ImagePainterTestNg_DrawImage002, TestSize.Level1) 712 { 713 RefPtr<NG::CanvasImage> canvasImage; 714 NG::ImagePainter imagePainter(canvasImage); 715 NG::ImagePaintConfig imagePaintConfig; 716 imagePainter.DrawImage(testingCanvas, OFFSETF, SIZE); 717 EXPECT_EQ(imagePainter.canvasImage_, nullptr); 718 719 imagePainter.canvasImage_ = AceType::MakeRefPtr<NG::MockCanvasImage>(); 720 imagePainter.canvasImage_->paintConfig_ = std::make_unique<NG::ImagePaintConfig>(); 721 imagePainter.DrawImage(testingCanvas, OFFSETF, SIZE); 722 EXPECT_NE(imagePainter.canvasImage_, nullptr); 723 724 imagePaintConfig.isSvg_ = true; 725 imagePainter.canvasImage_->paintConfig_ = std::make_unique<NG::ImagePaintConfig>(imagePaintConfig); 726 imagePainter.DrawImage(testingCanvas, OFFSETF, SIZE); 727 EXPECT_NE(imagePainter.canvasImage_->paintConfig_, nullptr); 728 } 729 730 /** 731 * @tc.name: ImagePainterTestNg_DrawObscuration002 732 * @tc.desc: Test cast to DrawObscuration 733 * @tc.type: FUNC 734 */ 735 HWTEST_F(ImagePainterTestNg, ImagePainterTestNg_DrawObscuration002, TestSize.Level1) 736 { 737 RefPtr<NG::CanvasImage> canvasImage; 738 NG::ImagePainter imagePainter(canvasImage); 739 NG::ImagePaintConfig imagePaintConfig; 740 imagePainter.DrawObscuration(testingCanvas, OFFSETF, SIZE); 741 EXPECT_EQ(imagePainter.canvasImage_, nullptr); 742 } 743 744 /** 745 * @tc.name: ImagePainterTestNg_CalculateBgWidth001 746 * @tc.desc: Test cast to CalculateBgWidth 747 * @tc.type: FUNC 748 */ 749 HWTEST_F(ImagePainterTestNg, ImagePainterTestNg_CalculateBgImageSize001, TestSize.Level1) 750 { 751 NG::SizeF boxPaintSize1 { 1, 1 }; 752 NG::SizeF srcSize1 = { 0, 0 }; 753 BackgroundImageSize backgroundImageSize1(BackgroundImageSizeType::COVER, 1, BackgroundImageSizeType::COVER, 1); 754 const std::optional<BackgroundImageSize>& bgImageSizeOpt1 = backgroundImageSize1; 755 NG::ImagePainter::CalculateBgImageSize(boxPaintSize1, srcSize1, bgImageSizeOpt1); 756 757 BackgroundImageSize backgroundImageSize2(BackgroundImageSizeType::CONTAIN, 1, BackgroundImageSizeType::CONTAIN, 1); 758 const std::optional<BackgroundImageSize>& bgImageSizeOpt2 = backgroundImageSize2; 759 NG::ImagePainter::CalculateBgImageSize(boxPaintSize1, srcSize1, bgImageSizeOpt2); 760 auto width = boxPaintSize1.Width(); 761 EXPECT_EQ(width, 1); 762 } 763 764 /** 765 * @tc.name: ImagePainterTestNg_CalculateBgWidth002 766 * @tc.desc: Test cast to CalculateBgWidth 767 * @tc.type: FUNC 768 */ 769 HWTEST_F(ImagePainterTestNg, ImagePainterTestNg_CalculateBgImageSize002, TestSize.Level1) 770 { 771 NG::SizeF boxPaintSize1 { 1, 1 }; 772 NG::SizeF srcSize1 = { 0, 1 }; 773 BackgroundImageSize backgroundImageSize1(BackgroundImageSizeType::COVER, 1, BackgroundImageSizeType::COVER, 1); 774 const std::optional<BackgroundImageSize>& bgImageSizeOpt1 = backgroundImageSize1; 775 NG::ImagePainter::CalculateBgImageSize(boxPaintSize1, srcSize1, bgImageSizeOpt1); 776 777 BackgroundImageSize backgroundImageSize2(BackgroundImageSizeType::CONTAIN, 1, BackgroundImageSizeType::CONTAIN, 1); 778 const std::optional<BackgroundImageSize>& bgImageSizeOpt2 = backgroundImageSize2; 779 NG::ImagePainter::CalculateBgImageSize(boxPaintSize1, srcSize1, bgImageSizeOpt2); 780 781 NG::SizeF boxPaintSize2 { 0, 0 }; 782 NG::SizeF srcSize2 = { 1, 0 }; 783 NG::ImagePainter::CalculateBgImageSize(boxPaintSize2, srcSize2, bgImageSizeOpt1); 784 785 NG::ImagePainter::CalculateBgImageSize(boxPaintSize2, srcSize2, bgImageSizeOpt2); 786 auto width = boxPaintSize2.Width(); 787 EXPECT_EQ(width, 0); 788 } 789 } // namespace OHOS::Ace 790