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 public:
66 void CallBack(Testing::MockCanvas& rSCanvas);
67 };
68
CallBack(Testing::MockCanvas & rSCanvas)69 void ImagePainterTestNg::CallBack(Testing::MockCanvas& rSCanvas)
70 {
71 EXPECT_CALL(rSCanvas, AttachBrush(_)).WillRepeatedly(ReturnRef(rSCanvas));
72 EXPECT_CALL(rSCanvas, DetachBrush()).WillRepeatedly(ReturnRef(rSCanvas));
73 EXPECT_CALL(rSCanvas, AttachPen(_)).WillRepeatedly(ReturnRef(rSCanvas));
74 EXPECT_CALL(rSCanvas, DetachPen()).WillRepeatedly(ReturnRef(rSCanvas));
75 }
76
77 /**
78 * @tc.name: ImagePainterTestNg_DrawImage1
79 * @tc.desc: Test cast to CirclePainterTestNg
80 * @tc.type: FUNC
81 */
82 HWTEST_F(ImagePainterTestNg, ImagePainterTestNg_DrawImage1, TestSize.Level1)
83 {
84 Testing::MockCanvas* canvasPtr = new Testing::MockCanvas();
85 Testing::MockCanvas& canvas = *canvasPtr;
86 /**
87 * @tc.steps1: build a imagePainter and imagePaintConfig object.
88 */
89 CallBack(canvas);
90 RefPtr<NG::CanvasImage> canvasImage;
91 NG::ImagePainter imagePainter(canvasImage);
92 NG::ImagePaintConfig imagePaintConfig;
93
94 /**
95 * @tc.steps2: callback DrawImage.
96 * @tc.expected: expect imagePainter.canvasImage_ is null.
97 */
98 imagePainter.DrawImage(canvas, OFFSETF, SIZE);
99 EXPECT_EQ(imagePainter.canvasImage_, nullptr);
100
101 /**
102 * @tc.steps3: build a cavans image object.
103 */
104 imagePainter.canvasImage_ = AceType::MakeRefPtr<NG::MockCanvasImage>();
105 imagePainter.canvasImage_->paintConfig_ = std::make_unique<NG::ImagePaintConfig>();
106
107 /**
108 * @tc.steps4: callback DrawImage.
109 * @tc.expected: expect imagePainter.canvasImage_ is not null.
110 */
111 imagePainter.DrawImage(canvas, OFFSETF, SIZE);
112 ASSERT_NE(imagePainter.canvasImage_, nullptr);
113
114 imagePaintConfig.isSvg_ = true;
115 imagePainter.canvasImage_->paintConfig_ = std::make_unique<NG::ImagePaintConfig>(imagePaintConfig);
116 imagePainter.DrawImage(canvas, OFFSETF, SIZE);
117
118 /**
119 * @tc.steps5: Assign values to call parameters.
120 */
121 imagePaintConfig.imageRepeat_ = ImageRepeat::REPEAT;
122 imagePaintConfig.isSvg_ = false;
123 imagePainter.canvasImage_->paintConfig_ = std::make_unique<NG::ImagePaintConfig>(imagePaintConfig);
124
125 /**
126 * @tc.steps6: callback DrawImage.
127 * @tc.expected: expect contentRect.Width and contentRect.Height are 1.
128 */
129 imagePainter.DrawImage(canvas, OFFSETF, SIZE);
130 EXPECT_EQ(CONTENTRECT.Width(), 1);
131 EXPECT_EQ(CONTENTRECT.Height(), 1);
132
133 /**
134 * @tc.steps7: callback DrawImage.
135 * @tc.expected: expect imagePainter.canvasImage_ is not null
136 */
137 ASSERT_NE(imagePainter.canvasImage_->paintConfig_, nullptr);
138 std::vector<ObscuredReasons> reasons;
139 reasons.emplace_back(static_cast<ObscuredReasons>(0));
140 imagePainter.canvasImage_->paintConfig_->obscuredReasons_ = reasons;
141 imagePainter.DrawImage(canvas, OFFSETF, SIZE);
142 EXPECT_NE(imagePainter.canvasImage_, nullptr);
143 testing::Mock::AllowLeak(canvasPtr);
144 }
145
146 /**
147 * @tc.name: ImagePainterTestNg_DrawObscuration001
148 * @tc.desc: Test DrawObscuration
149 * @tc.type: FUNC
150 */
151 HWTEST_F(ImagePainterTestNg, ImagePainterTestNg_DrawObscuration001, TestSize.Level1)
152 {
153 Testing::MockCanvas* canvasPtr = new Testing::MockCanvas();
154 Testing::MockCanvas& canvas = *canvasPtr;
155
156 /**
157 * @tc.steps1: create a imagePainter and imagePaintConfig object.
158 */
159 CallBack(canvas);
160 RefPtr<NG::CanvasImage> canvasImage;
161 NG::ImagePainter imagePainter(canvasImage);
162 NG::ImagePaintConfig imagePaintConfig;
163 /**
164 * @tc.steps2: build a pixelMapImage object.
165 */
166 imagePainter.canvasImage_ = AceType::MakeRefPtr<NG::MockCanvasImage>();
167 imagePainter.canvasImage_->paintConfig_ = std::make_unique<NG::ImagePaintConfig>();
168 ASSERT_NE(imagePainter.canvasImage_, nullptr);
169 ASSERT_NE(imagePainter.canvasImage_->paintConfig_, nullptr);
170 /**
171 * @tc.steps3: call DrawObscuration.
172 * @tc.expected: expect canvasImage_.borderRadiusXY_ is null
173 */
174 imagePainter.DrawObscuration(canvas, OFFSETF, SIZE);
175 imagePainter.canvasImage_->paintConfig_->isSvg_ = true;
176 imagePainter.DrawObscuration(canvas, OFFSETF, SIZE);
177 EXPECT_EQ(imagePainter.canvasImage_->paintConfig_->borderRadiusXY_, nullptr);
178 /**
179 * @tc.steps4: set radiusXY to canvasImage_.borderRadiusXY_ and call DrawObscuration
180 * @tc.expected: expect canvasImage_.borderRadiusXY_ is not null
181 */
182 NG::BorderRadiusArray radiusXY = { pointF_, pointF_, pointF_, pointF_ };
183 imagePainter.canvasImage_->paintConfig_->borderRadiusXY_ = std::make_shared<NG::BorderRadiusArray>(radiusXY);
184 imagePainter.DrawObscuration(canvas, OFFSETF, SIZE);
185 EXPECT_NE(imagePainter.canvasImage_->paintConfig_->borderRadiusXY_, nullptr);
186 testing::Mock::AllowLeak(canvasPtr);
187 }
188
189 /**
190 * @tc.name: ImagePainterTestNg_DrawSVGImage2
191 * @tc.desc: Test cast to CirclePainterTestNg
192 * @tc.type: FUNC
193 */
194 HWTEST_F(ImagePainterTestNg, ImagePainterTestNg_DrawSVGImage2, TestSize.Level1)
195 {
196 /**
197 * @tc.steps1: build a imagePainter and imagePaintConfig object.
198 */
199 RefPtr<NG::CanvasImage> canvasImage;
200 NG::ImagePainter imagePainter(canvasImage);
201 NG::ImagePaintConfig imagePaintConfig;
202
203 /**
204 * @tc.steps2: callback DrawImage.
205 * @tc.expected: expect imagePainter.canvasImage_ is null.
206 */
207 EXPECT_EQ(imagePainter.canvasImage_, nullptr);
208
209 /**
210 * @tc.steps3: build a pixelMapImage object.
211 */
212 imagePainter.canvasImage_ = AceType::MakeRefPtr<NG::MockCanvasImage>();
213 imagePainter.canvasImage_->paintConfig_ = std::make_unique<NG::ImagePaintConfig>();
214 /**
215 * @tc.steps4: Assign values to call parameters.
216 */
217 imagePaintConfig.flipHorizontally_ = true;
218 imagePainter.canvasImage_->paintConfig_ = std::make_unique<NG::ImagePaintConfig>(imagePaintConfig);
219
220 /**
221 * @tc.steps5: callback DrawImage.
222 * @tc.expected: expect OFFSETF.GetX() is 1 and test is 0.
223 */
224 imagePainter.DrawSVGImage(testingCanvas, OFFSETF, SIZE);
225 EXPECT_EQ(OFFSETF.GetX(), 1);
226 auto test = imagePainter.canvasImage_->GetPaintConfig().dstRect_.Width();
227 EXPECT_EQ(test, 0);
228 }
229
230 /**
231 * @tc.name: ImagePainterTestNg_DrawStaticImage3
232 * @tc.desc: Test cast to CirclePainterTestNg
233 * @tc.type: FUNC
234 */
235 HWTEST_F(ImagePainterTestNg, ImagePainterTestNg_DrawStaticImage3, TestSize.Level1)
236 {
237 /**
238 * @tc.steps1: build a imagePainter and imagePaintConfig object.
239 */
240 RefPtr<NG::CanvasImage> canvasImage;
241 NG::ImagePainter imagePainter(canvasImage);
242 NG::ImagePaintConfig imagePaintConfig;
243
244 /**
245 * @tc.steps2: callback DrawImage.
246 * @tc.expected: expect imagePainter.canvasImage_ is null.
247 */
248 imagePainter.DrawStaticImage(testingCanvas, OFFSETF, SIZE);
249 EXPECT_EQ(imagePainter.canvasImage_, nullptr);
250
251 /**
252 * @tc.steps3: build a pixelMapImage object.
253 */
254 imagePainter.canvasImage_ = AceType::MakeRefPtr<NG::MockCanvasImage>();
255 imagePainter.canvasImage_->paintConfig_ = std::make_unique<NG::ImagePaintConfig>();
256 /**
257 * @tc.steps4: Assign values to call parameters.
258 */
259 imagePaintConfig.renderMode_ = ImageRenderMode::TEMPLATE;
260 imagePainter.canvasImage_->paintConfig_ = std::make_unique<NG::ImagePaintConfig>(imagePaintConfig);
261
262 /**
263 * @tc.steps5: callback DrawStaticImage.
264 * @tc.expected: expect OFFSETF.GetX() and OFFSETF.GetY() are 1.
265 */
266 imagePainter.DrawStaticImage(testingCanvas, OFFSETF, SIZE);
267 EXPECT_EQ(OFFSETF.GetX(), 1);
268 EXPECT_EQ(OFFSETF.GetY(), 1);
269
270 /**
271 * @tc.steps6: Assign values to call parameters.
272 */
273 imagePaintConfig.flipHorizontally_ = true;
274 imagePainter.canvasImage_->paintConfig_ = std::make_unique<NG::ImagePaintConfig>(imagePaintConfig);
275
276 /**
277 * @tc.steps7: callback DrawStaticImage.
278 * @tc.expected: expect OFFSETF.GetX() is 1 and test is 0.
279 */
280 imagePainter.DrawStaticImage(testingCanvas, OFFSETF, SIZE);
281 EXPECT_EQ(OFFSETF.GetX(), 1);
282 auto test = imagePainter.canvasImage_->GetPaintConfig().dstRect_.Width();
283 EXPECT_EQ(test, 0);
284 }
285
286 /**
287 * @tc.name: ImagePainterTestNg_FlipHorizontal4
288 * @tc.desc: Test cast to CirclePainterTestNg
289 * @tc.type: FUNC
290 */
291 HWTEST_F(ImagePainterTestNg, ImagePainterTestNg_FlipHorizontal4, TestSize.Level1)
292 {
293 /**
294 * @tc.steps1: build a imagePainter object.
295 */
296 RefPtr<NG::CanvasImage> canvasImage;
297 NG::ImagePainter imagePainter(canvasImage);
298
299 /**
300 * @tc.steps2: callback DrawImage.
301 */
302 imagePainter.FlipHorizontal(testingCanvas, SIZE);
303 }
304
305 /**
306 * @tc.name: ImagePainterTestNg_DrawImageWithRepeat5
307 * @tc.desc: Test cast to CirclePainterTestNg
308 * @tc.type: FUNC
309 */
310 HWTEST_F(ImagePainterTestNg, ImagePainterTestNg_DrawImageWithRepeat5, TestSize.Level1)
311 {
312 /**
313 * @tc.steps1: build a imagePainter object.
314 */
315 RefPtr<NG::CanvasImage> canvasImage;
316 NG::ImagePainter imagePainter(canvasImage);
317 NG::ImagePaintConfig imagePaintConfig;
318
319 /**
320 * @tc.steps2 build a pixelMapImage object.
321 */
322 imagePainter.canvasImage_ = AceType::MakeRefPtr<NG::MockCanvasImage>();
323 imagePainter.canvasImage_->paintConfig_ = std::make_unique<NG::ImagePaintConfig>();
324
325 /**
326 * @tc.steps3callback DrawImageWithRepeat.
327 * @tc.expected: expect CONTENTRECT.Width() and CONTENTRECT.Height() is 0.
328 */
329 imagePainter.DrawImageWithRepeat(testingCanvas, CONTENTRECT);
330 EXPECT_EQ(CONTENTRECT.Width(), 1);
331 EXPECT_EQ(CONTENTRECT.Height(), 1);
332
333 /**
334 * @tc.steps4: Assign values to call parameters.
335 */
336 imagePaintConfig.imageRepeat_ = ImageRepeat::REPEAT;
337 imagePaintConfig.dstRect_.width_ = 1;
338 imagePaintConfig.dstRect_.height_ = 1;
339 imagePainter.canvasImage_->paintConfig_ = std::make_unique<NG::ImagePaintConfig>(imagePaintConfig);
340
341 /**
342 * @tc.steps5 callback DrawImageWithRepeat.
343 * @tc.expected: expect CONTENTRECT.GetOffset().GetX and CONTENTRECT.GetOffset().GetY is 0.
344 */
345 imagePainter.DrawImageWithRepeat(testingCanvas, CONTENTRECT);
346 EXPECT_EQ(CONTENTRECT.GetOffset().GetX(), 1);
347 EXPECT_EQ(CONTENTRECT.GetOffset().GetY(), 1);
348
349 /**
350 * @tc.steps6: Assign values to call parameters.
351 */
352 imagePaintConfig.imageRepeat_ = ImageRepeat::REPEAT_X;
353 imagePaintConfig.imageRepeat_ = ImageRepeat::REPEAT_Y;
354 imagePaintConfig.dstRect_.width_ = 1;
355 imagePaintConfig.dstRect_.height_ = 1;
356 imagePainter.canvasImage_->paintConfig_ = std::make_unique<NG::ImagePaintConfig>(imagePaintConfig);
357 imagePainter.DrawImageWithRepeat(testingCanvas, CONTENTRECT);
358 }
359
360 /**
361 * @tc.name: ImagePainterTestNg_ApplyImageFit6
362 * @tc.desc: Test cast to CirclePainterTestNg
363 * @tc.type: FUNC
364 */
365 HWTEST_F(ImagePainterTestNg, ImagePainterTestNg_ApplyImageFit6, TestSize.Level1)
366 {
367 /**
368 * @tc.steps1: build a imagePainter object.
369 */
370 RefPtr<NG::CanvasImage> canvasImage;
371 NG::ImagePainter imagePainter(canvasImage);
372 NG::RectF srcRect_;
373 NG::RectF dstRect_;
374
375 /**
376 * @tc.steps2: callback ApplyImageFit.
377 * @tc.expected: expect viewScale is 1.
378 */
379 imagePainter.ApplyImageFit(ImageFit::FILL, rawpicsize, dstsize, srcRect_, dstRect_);
380 auto context = PipelineContext::GetCurrentContext();
381 float viewScale = context ? context->GetViewScale() : 1.0;
382 EXPECT_EQ(viewScale, 1);
383
384 /**
385 * @tc.steps3: callback ApplyImageFit when ImageFit::NONE.
386 * @tc.expected: expect testsize.GetX() and testsize.GetY() are 1.
387 */
388 imagePainter.ApplyImageFit(ImageFit::NONE, rawpicsize, dstsize, srcRect_, dstRect_);
389 NG::SizeF srcSize(std::min(dstsize.Width(), rawpicsize.Width()), std::min(dstsize.Height(), rawpicsize.Height()));
390 auto testSize = Alignment::GetAlignPosition(dstsize, srcSize, Alignment::CENTER);
391 EXPECT_EQ(testSize.GetX(), 0);
392 EXPECT_EQ(testSize.GetY(), 0);
393
394 /**
395 * @tc.steps4: callback ApplyImageFit when ImageFit::COVER.
396 * @tc.expected: expect testsize1.GetX() and testsize1.GetY() are 1.
397 */
398 imagePainter.ApplyImageFit(ImageFit::COVER, rawpicsize, dstsize, srcRect_, dstRect_);
399 auto testSize1 = Alignment::GetAlignPosition(rawpicsize, srcRect_.GetSize(), Alignment::CENTER);
400 EXPECT_EQ(testSize1.GetX(), 0);
401 EXPECT_EQ(testSize1.GetY(), 0);
402
403 /**
404 * @tc.steps5: callback ApplyImageFit when ImageFit::FITWIDTH.
405 * @tc.expected: expect testsize2.GetX() and testsize2.GetY() are 1.
406 */
407 imagePainter.ApplyImageFit(ImageFit::FITWIDTH, rawpicsize, dstsize, srcRect_, dstRect_);
408 auto testSize2 = Alignment::GetAlignPosition(rawpicsize, srcRect_.GetSize(), Alignment::CENTER);
409 EXPECT_EQ(testSize2.GetX(), 0);
410 EXPECT_EQ(testSize2.GetY(), 0);
411
412 /**
413 * @tc.steps6: callback ApplyImageFit when ImageFit::FITHEIGHT.
414 * @tc.expected: expect testsize3.GetX() and testsize3.GetY() are 1.
415 */
416 imagePainter.ApplyImageFit(ImageFit::FITHEIGHT, rawpicsize, dstsize, srcRect_, dstRect_);
417 auto testSize3 = Alignment::GetAlignPosition(dstsize, dstRect_.GetSize(), Alignment::CENTER);
418 EXPECT_EQ(testSize3.GetX(), 0);
419 EXPECT_EQ(testSize3.GetY(), 0);
420
421 /**
422 * @tc.steps7: callback ApplyImageFit when ImageFit::SCALE_DOWN.
423 * @tc.expected: expect testsize4.GetX() and testsize4.GetY() are 1.
424 */
425 imagePainter.ApplyImageFit(ImageFit::SCALE_DOWN, rawpicsize, dstsize, srcRect_, dstRect_);
426 NG::SizeF srcSize1(std::min(dstsize.Width(), rawpicsize.Width()), std::min(dstsize.Height(), rawpicsize.Height()));
427 auto testSize4 = Alignment::GetAlignPosition(dstsize, srcSize1, Alignment::CENTER);
428 EXPECT_EQ(testSize4.GetX(), 0);
429 EXPECT_EQ(testSize4.GetY(), 0);
430
431 /**
432 * @tc.steps8: callback ApplyImageFit when ImageFit::CONTAIN.
433 * @tc.expected: expect testsize8.GetX() and testsize8.GetY() are 1.
434 */
435 imagePainter.ApplyImageFit(ImageFit::CONTAIN, rawpicsize, dstsize, srcRect_, dstRect_);
436 auto testSize5 = Alignment::GetAlignPosition(dstsize, dstRect_.GetSize(), Alignment::CENTER);
437 EXPECT_EQ(testSize5.GetX(), 0);
438 EXPECT_EQ(testSize5.GetY(), 0);
439
440 /**
441 * @tc.steps9: callback ApplyImageFit when ImageFit::COVER_TOP_LEFT.
442 * @tc.expected: expect testsize6.GetX() and testsize6.GetY() are 1.
443 */
444 imagePainter.ApplyImageFit(ImageFit::COVER_TOP_LEFT, rawpicsize, dstsize, srcRect_, dstRect_);
445 auto testSize6 = Alignment::GetAlignPosition(dstsize, dstRect_.GetSize(), Alignment::CENTER);
446 EXPECT_EQ(testSize6.GetX(), 0);
447 EXPECT_EQ(testSize6.GetY(), 0);
448 }
449
450 /**
451 * @tc.name: ImagePainterTestNg_ImagePainter7
452 * @tc.desc: Test cast to CirclePainterTestNg
453 * @tc.type: FUNC
454 */
455 HWTEST_F(ImagePainterTestNg, ImagePainterTestNg_ImagePainter7, TestSize.Level1)
456 {
457 /**
458 * @tc.steps1: build a imagePainter object.
459 */
460 RefPtr<NG::CanvasImage> canvasImage;
461 NG::ImagePainter imagePainter(canvasImage);
462 const NG::SizeF boxPaintSize_;
463 const NG::SizeF imageRenderSize_;
464 BackgroundImagePosition backgroundImagePosition(
465 BackgroundImagePositionType::PERCENT, 1, BackgroundImagePositionType::PERCENT, 1);
466 std::optional<BackgroundImagePosition> bgImgPositionOpt = backgroundImagePosition;
467
468 /**
469 * @tc.steps2: callback CalculateBgImagePosition when BackgroundImagePositionType::PERCENT.
470 * @tc.expected: expect offset.GetX() and offset.GetY() are 0.
471 */
472 auto offset = imagePainter.CalculateBgImagePosition(boxPaintSize_, imageRenderSize_, bgImgPositionOpt);
473 EXPECT_EQ(offset.GetX(), 0);
474 EXPECT_EQ(offset.GetY(), 0);
475
476 /**
477 * @tc.steps3: callback CalculateBgImagePosition when BackgroundImagePositionType::PX.
478 * @tc.expected: expect offset.GetX() and offset.GetY() are 0.
479 */
480 BackgroundImagePosition backgroundImagePosition1(
481 BackgroundImagePositionType::PX, 1, BackgroundImagePositionType::PX, 1);
482 std::optional<BackgroundImagePosition> bgImgPositionOpt1 = backgroundImagePosition1;
483 auto offset1 = imagePainter.CalculateBgImagePosition(boxPaintSize_, imageRenderSize_, bgImgPositionOpt1);
484 EXPECT_EQ(offset1.GetX(), 1);
485 EXPECT_EQ(offset1.GetY(), 1);
486
487 /**
488 * @tc.steps3: callback CalculateBgImagePosition and reset bgImgPositionOpt.
489 * @tc.expected: expect offset.GetX() and offset.GetY() are 0.
490 */
491 BackgroundImagePosition backgroundImagePosition2(
492 BackgroundImagePositionType::PX, 1, BackgroundImagePositionType::PX, 1);
493 std::optional<BackgroundImagePosition> bgImgPositionOpt2 = backgroundImagePosition2;
494 bgImgPositionOpt2.reset();
495 auto offset2 = imagePainter.CalculateBgImagePosition(boxPaintSize_, imageRenderSize_, bgImgPositionOpt2);
496 EXPECT_EQ(offset2.GetX(), 0);
497 EXPECT_EQ(offset2.GetY(), 0);
498 }
499
500 /**
501 * @tc.name: ImagePainterTestNg_CalculateBgImageSize8
502 * @tc.desc: Test cast to CirclePainterTestNg
503 * @tc.type: FUNC
504 */
505 HWTEST_F(ImagePainterTestNg, ImagePainterTestNg_CalculateBgImageSize8, TestSize.Level1)
506 {
507 /**
508 * @tc.steps1: creat a bgImageSizeOpt std::optiona.
509 */
510 BackgroundImageSize backgroundImageSize1(BackgroundImageSizeType::AUTO, 2, BackgroundImageSizeType::AUTO, 2);
511 std::optional<BackgroundImageSize> bgImageSizeOpt1 = backgroundImageSize1;
512
513 /**
514 * @tc.steps2: callback CalculateBgImageSize when valueX_ is 2.
515 * @tc.expected: expect sizeRet.Width() and sizeRet.Height() are 2.
516 */
517 auto sizeRet = NG::ImagePainter::CalculateBgImageSize(boxPaintSize_, srcSize, bgImageSizeOpt1);
518 EXPECT_EQ(sizeRet.Width(), 1);
519 EXPECT_EQ(sizeRet.Height(), 1);
520
521 /**
522 * @tc.steps3: callback CalculateBgImageSize when valueX_ is -1.
523 * @tc.expected: expect sizeRet.Width() and sizeRet.Height() are -1.
524 */
525 BackgroundImageSize backgroundImageSize2(BackgroundImageSizeType::LENGTH, -1, BackgroundImageSizeType::LENGTH, -1);
526 std::optional<BackgroundImageSize> bgImageSizeOpt2 = backgroundImageSize2;
527 auto sizeRet1 = NG::ImagePainter::CalculateBgImageSize(boxPaintSize_, srcSize, bgImageSizeOpt2);
528 EXPECT_EQ(sizeRet1.Width(), -1);
529 EXPECT_EQ(sizeRet1.Height(), -1);
530
531 /**
532 * @tc.steps4: callback CalculateBgImageSize when valueX_ is 1 and valueY is 11.
533 * @tc.expected: expect sizeRet.Width() and sizeRet.Height() are 2.
534 */
535 BackgroundImageSize backgroundImageSize3(BackgroundImageSizeType::LENGTH, 1, BackgroundImageSizeType::LENGTH, -1);
536 std::optional<BackgroundImageSize> bgImageSizeOpt3 = backgroundImageSize3;
537 auto sizeRet2 = NG::ImagePainter::CalculateBgImageSize(boxPaintSize_, srcSize, bgImageSizeOpt3);
538 EXPECT_EQ(sizeRet2.Width(), 1);
539 EXPECT_EQ(sizeRet2.Height(), 1);
540
541 /**
542 * @tc.steps5: callback CalculateBgImageSize when valueX_ is -1 and valueY is -1.
543 * @tc.expected: expect sizeRet.Width() and sizeRet.Height() are -1.
544 */
545 srcSize = { -1, -1 };
546 boxPaintSize_ = { -1, -1 };
547 BackgroundImageSize backgroundImageSize4(BackgroundImageSizeType::LENGTH, 1, BackgroundImageSizeType::LENGTH, -1);
548 std::optional<BackgroundImageSize> bgImageSizeOpt4 = backgroundImageSize4;
549 bgImageSizeOpt4.reset();
550 auto sizeRet3 = NG::ImagePainter::CalculateBgImageSize(boxPaintSize_, srcSize, bgImageSizeOpt4);
551 EXPECT_EQ(sizeRet3.Width(), -1);
552 EXPECT_EQ(sizeRet3.Height(), -1);
553 }
554
555 /**
556 * @tc.name: ImagePainterTestNg_CalculateBgWidth9
557 * @tc.desc: Test cast to CirclePainterTestNg
558 * @tc.type: FUNC
559 */
560 HWTEST_F(ImagePainterTestNg, ImagePainterTestNg_CalculateBgWidth9, TestSize.Level1)
561 {
562 /**
563 * @tc.steps1: creat a backgroundImageSize object.
564 */
565 BackgroundImageSize backgroundImageSize(BackgroundImageSizeType::AUTO, 2, BackgroundImageSizeType::AUTO, 2);
566
567 /**
568 * @tc.steps2: creat for loop change BackgroundImageSizeTypeX and callback CalculateBgImageSize.
569 * @tc.expected: expect offset.GetX() and offset.GetY() are -1.
570 */
571 for (int32_t index = 0; index <= 4; index++) {
572 backgroundImageSize.typeX_ = static_cast<BackgroundImageSizeType>(index);
573 const std::optional<BackgroundImageSize>& bgImageSizeOpt = backgroundImageSize;
574 NG::ImagePainter::CalculateBgImageSize(boxPaintSize_, srcSize, bgImageSizeOpt);
575 switch (backgroundImageSize.typeX_) {
576 case BackgroundImageSizeType::COVER:
577 EXPECT_EQ(srcSize.Width(), -1);
578 break;
579 case BackgroundImageSizeType::CONTAIN:
580 EXPECT_EQ(srcSize.Width(), -1);
581 break;
582 case BackgroundImageSizeType::LENGTH:
583 EXPECT_EQ(srcSize.Width(), -1);
584 break;
585 case BackgroundImageSizeType::PERCENT:
586 EXPECT_EQ(srcSize.Width(), -1);
587 break;
588 default:
589 break;
590 }
591 }
592
593 /**
594 * @tc.steps3: creat for loop change BackgroundImageSizeTypeY and callback CalculateBgImageSize.
595 * @tc.expected: expect offset.GetX() and offset.GetY() are -1.
596 */
597 for (int32_t index = 0; index <= 4; index++) {
598 backgroundImageSize.typeY_ = static_cast<BackgroundImageSizeType>(index);
599 const std::optional<BackgroundImageSize>& bgImageSizeOpt = backgroundImageSize;
600 NG::ImagePainter::CalculateBgImageSize(boxPaintSize_, srcSize, bgImageSizeOpt);
601 switch (backgroundImageSize.typeY_) {
602 case BackgroundImageSizeType::COVER:
603 EXPECT_EQ(srcSize.Height(), -1);
604 break;
605 case BackgroundImageSizeType::CONTAIN:
606 EXPECT_EQ(srcSize.Height(), -1);
607 break;
608 case BackgroundImageSizeType::LENGTH:
609 EXPECT_EQ(srcSize.Height(), -1);
610 break;
611 case BackgroundImageSizeType::PERCENT:
612 EXPECT_EQ(srcSize.Height(), -1);
613 break;
614 default:
615 break;
616 }
617 }
618 }
619
620 /**
621 * @tc.name: ImagePainterTestNg_CalculateBgWidth10
622 * @tc.desc: Test cast to CirclePainterTestNg
623 * @tc.type: FUNC
624 */
625 HWTEST_F(ImagePainterTestNg, ImagePainterTestNg_CalculateBgImageSize10, TestSize.Level1)
626 {
627 /**
628 * @tc.steps1: creat a bgImageSizeOpt1 and callback CalculateBgImageSize.
629 * @tc.expected: expect width1 is -2.
630 */
631 srcSize = { 2, 1 };
632 BackgroundImageSize backgroundImageSize1(BackgroundImageSizeType::COVER, 1, BackgroundImageSizeType::COVER, 1);
633 const std::optional<BackgroundImageSize>& bgImageSizeOpt1 = backgroundImageSize1;
634 NG::ImagePainter::CalculateBgImageSize(boxPaintSize_, srcSize, bgImageSizeOpt1);
635 auto width1 = srcSize.Width() * (boxPaintSize_.Height() / srcSize.Height());
636 EXPECT_EQ(width1, -2);
637
638 /**
639 * @tc.steps2: creat a bgImageSizeOpt2 and callback CalculateBgImageSize.
640 * @tc.expected: expect width1 is 1.
641 */
642 srcSize = { 2, 1 };
643 BackgroundImageSize backgroundImageSize2(BackgroundImageSizeType::CONTAIN, 1, BackgroundImageSizeType::CONTAIN, 1);
644 const std::optional<BackgroundImageSize>& bgImageSizeOpt2 = backgroundImageSize2;
645 NG::ImagePainter::CalculateBgImageSize(boxPaintSize_, srcSize, bgImageSizeOpt2);
646 auto width2 = boxPaintSize_.Width();
647 EXPECT_EQ(width2, -1);
648 }
649
650 /**
651 * @tc.name: ImagePainterTestNg_ApplyImageFit11
652 * @tc.desc: Test cast to CirclePainterTestNg
653 * @tc.type: FUNC
654 */
655 HWTEST_F(ImagePainterTestNg, ImagePainterTestNg_ApplyImageFit11, TestSize.Level1)
656 {
657 /**
658 * @tc.steps1: build a imagePainter object.
659 */
660 RefPtr<NG::CanvasImage> canvasImage;
661 NG::ImagePainter imagePainter(canvasImage);
662 rawpicsize = { 10, 1 };
663
664 /**
665 * @tc.steps2: callback ApplyImageFit when ImageFit::COVER.
666 * @tc.expected: expect testsize1.GetX() is 4.5 and testsize1.GetY() is 0.
667 */
668 imagePainter.ApplyImageFit(ImageFit::COVER, rawpicsize, dstsize, srcRect_, dstRect_);
669 auto testSize1 = Alignment::GetAlignPosition(rawpicsize, srcRect_.GetSize(), Alignment::CENTER);
670 EXPECT_EQ(testSize1.GetX(), 4.5);
671 EXPECT_EQ(testSize1.GetY(), 0);
672
673 /**
674 * @tc.steps3: callback ApplyImageFit when ImageFit::FITWIDTH.
675 * @tc.expected: expect testsize2.GetX() and testsize2.GetY() are 0.
676 */
677 imagePainter.ApplyImageFit(ImageFit::FITWIDTH, rawpicsize, dstsize, srcRect_, dstRect_);
678 auto testSize2 = Alignment::GetAlignPosition(rawpicsize, srcRect_.GetSize(), Alignment::CENTER);
679 EXPECT_EQ(testSize2.GetX(), 0);
680 EXPECT_EQ(testSize2.GetY(), 0);
681
682 /**
683 * @tc.steps4: callback ApplyImageFit when ImageFit::FITHEIGHT.
684 * @tc.expected: expect testsize3.GetX() and testsize3.GetY() are 0.
685 */
686 imagePainter.ApplyImageFit(ImageFit::FITHEIGHT, rawpicsize, dstsize, srcRect_, dstRect_);
687 auto testSize3 = Alignment::GetAlignPosition(dstsize, dstRect_.GetSize(), Alignment::CENTER);
688 EXPECT_EQ(testSize3.GetX(), 0);
689 EXPECT_EQ(testSize3.GetY(), 0);
690
691 /**
692 * @tc.steps5: callback ApplyImageFit when ImageFit::CONTAIN.
693 * @tc.expected: expect testsize8.GetX() is 0 and testsize8.GetY() are 0.45.
694 */
695 imagePainter.ApplyImageFit(ImageFit::CONTAIN, rawpicsize, dstsize, srcRect_, dstRect_);
696 auto testSize4 = Alignment::GetAlignPosition(dstsize, dstRect_.GetSize(), Alignment::CENTER);
697 EXPECT_EQ(testSize4.GetX(), 0);
698 EXPECT_FLOAT_EQ(testSize4.GetY(), 0.45);
699
700 /**
701 * @tc.steps6: callback ApplyImageFit when ImageFit::CONTAIN.
702 * @tc.expected: expect testsize8.GetX() and testsize8.GetY() are 0.
703 */
704 rawpicsize = { -1, -1 };
705 imagePainter.ApplyImageFit(ImageFit::CONTAIN, rawpicsize, dstsize, srcRect_, dstRect_);
706 auto testSize5 = Alignment::GetAlignPosition(dstsize, dstRect_.GetSize(), Alignment::CENTER);
707 EXPECT_EQ(testSize5.GetX(), 0);
708 EXPECT_EQ(testSize5.GetY(), 0);
709
710 /**
711 * @tc.steps7: callback ApplyImageFit when ImageFit::COVER_TOP_LEFT.
712 * @tc.expected: expect testsize6.GetX() and testsize6.GetY() are 0.
713 */
714 rawpicsize = { -1, -1 };
715 imagePainter.ApplyImageFit(ImageFit::COVER_TOP_LEFT, rawpicsize, dstsize, srcRect_, dstRect_);
716 auto testSize6 = Alignment::GetAlignPosition(dstsize, dstRect_.GetSize(), Alignment::CENTER);
717 EXPECT_EQ(testSize6.GetX(), 0);
718 EXPECT_EQ(testSize6.GetY(), 0);
719 }
720
721 /**
722 * @tc.name: ImagePainterTestNg_DrawImage002
723 * @tc.desc: Test cast to DrawImage
724 * @tc.type: FUNC
725 */
726 HWTEST_F(ImagePainterTestNg, ImagePainterTestNg_DrawImage002, TestSize.Level1)
727 {
728 RefPtr<NG::CanvasImage> canvasImage;
729 NG::ImagePainter imagePainter(canvasImage);
730 NG::ImagePaintConfig imagePaintConfig;
731 imagePainter.DrawImage(testingCanvas, OFFSETF, SIZE);
732 EXPECT_EQ(imagePainter.canvasImage_, nullptr);
733
734 imagePainter.canvasImage_ = AceType::MakeRefPtr<NG::MockCanvasImage>();
735 imagePainter.canvasImage_->paintConfig_ = std::make_unique<NG::ImagePaintConfig>();
736 imagePainter.DrawImage(testingCanvas, OFFSETF, SIZE);
737 EXPECT_NE(imagePainter.canvasImage_, nullptr);
738
739 imagePaintConfig.isSvg_ = true;
740 imagePainter.canvasImage_->paintConfig_ = std::make_unique<NG::ImagePaintConfig>(imagePaintConfig);
741 imagePainter.DrawImage(testingCanvas, OFFSETF, SIZE);
742 EXPECT_NE(imagePainter.canvasImage_->paintConfig_, nullptr);
743 }
744
745 /**
746 * @tc.name: ImagePainterTestNg_DrawObscuration002
747 * @tc.desc: Test cast to DrawObscuration
748 * @tc.type: FUNC
749 */
750 HWTEST_F(ImagePainterTestNg, ImagePainterTestNg_DrawObscuration002, TestSize.Level1)
751 {
752 RefPtr<NG::CanvasImage> canvasImage;
753 NG::ImagePainter imagePainter(canvasImage);
754 NG::ImagePaintConfig imagePaintConfig;
755 EXPECT_EQ(imagePainter.canvasImage_, nullptr);
756 }
757
758 /**
759 * @tc.name: ImagePainterTestNg_CalculateBgWidth001
760 * @tc.desc: Test cast to CalculateBgWidth
761 * @tc.type: FUNC
762 */
763 HWTEST_F(ImagePainterTestNg, ImagePainterTestNg_CalculateBgImageSize001, TestSize.Level1)
764 {
765 NG::SizeF boxPaintSize1 { 1, 1 };
766 NG::SizeF srcSize1 = { 0, 0 };
767 BackgroundImageSize backgroundImageSize1(BackgroundImageSizeType::COVER, 1, BackgroundImageSizeType::COVER, 1);
768 const std::optional<BackgroundImageSize>& bgImageSizeOpt1 = backgroundImageSize1;
769 NG::ImagePainter::CalculateBgImageSize(boxPaintSize1, srcSize1, bgImageSizeOpt1);
770
771 BackgroundImageSize backgroundImageSize2(BackgroundImageSizeType::CONTAIN, 1, BackgroundImageSizeType::CONTAIN, 1);
772 const std::optional<BackgroundImageSize>& bgImageSizeOpt2 = backgroundImageSize2;
773 NG::ImagePainter::CalculateBgImageSize(boxPaintSize1, srcSize1, bgImageSizeOpt2);
774 auto width = boxPaintSize1.Width();
775 EXPECT_EQ(width, 1);
776 }
777
778 /**
779 * @tc.name: ImagePainterTestNg_CalculateBgWidth002
780 * @tc.desc: Test cast to CalculateBgWidth
781 * @tc.type: FUNC
782 */
783 HWTEST_F(ImagePainterTestNg, ImagePainterTestNg_CalculateBgImageSize002, TestSize.Level1)
784 {
785 NG::SizeF boxPaintSize1 { 1, 1 };
786 NG::SizeF srcSize1 = { 0, 1 };
787 BackgroundImageSize backgroundImageSize1(BackgroundImageSizeType::COVER, 1, BackgroundImageSizeType::COVER, 1);
788 const std::optional<BackgroundImageSize>& bgImageSizeOpt1 = backgroundImageSize1;
789 NG::ImagePainter::CalculateBgImageSize(boxPaintSize1, srcSize1, bgImageSizeOpt1);
790
791 BackgroundImageSize backgroundImageSize2(BackgroundImageSizeType::CONTAIN, 1, BackgroundImageSizeType::CONTAIN, 1);
792 const std::optional<BackgroundImageSize>& bgImageSizeOpt2 = backgroundImageSize2;
793 NG::ImagePainter::CalculateBgImageSize(boxPaintSize1, srcSize1, bgImageSizeOpt2);
794
795 NG::SizeF boxPaintSize2 { 0, 0 };
796 NG::SizeF srcSize2 = { 1, 0 };
797 NG::ImagePainter::CalculateBgImageSize(boxPaintSize2, srcSize2, bgImageSizeOpt1);
798
799 NG::ImagePainter::CalculateBgImageSize(boxPaintSize2, srcSize2, bgImageSizeOpt2);
800 auto width = boxPaintSize2.Width();
801 EXPECT_EQ(width, 0);
802 }
803
804 /**
805 * @tc.name: ImagePainterTestNg_DrawImageWithRepeat12
806 * @tc.desc: Test cast to CirclePainterTestNg
807 * @tc.type: FUNC
808 */
809 HWTEST_F(ImagePainterTestNg, ImagePainterTestNg_DrawImageWithRepeat12, TestSize.Level1)
810 {
811 /**
812 * @tc.steps1: build a imagePainter object.
813 */
814 RefPtr<NG::CanvasImage> canvasImage;
815 NG::ImagePainter imagePainter(canvasImage);
816 NG::ImagePaintConfig imagePaintConfig;
817
818 /**
819 * @tc.steps2 build a pixelMapImage object.
820 */
821 imagePainter.canvasImage_ = AceType::MakeRefPtr<NG::MockCanvasImage>();
822 imagePainter.canvasImage_->paintConfig_ = std::make_unique<NG::ImagePaintConfig>();
823 NG::RectF srcRect_(1.0f, 1.0f, 0.0001f, 0.0001f);
824
825 /**
826 * @tc.steps3callback DrawImageWithRepeat.
827 * @tc.expected: expect NearZero(singleImageHeight).
828 */
829 imagePainter.canvasImage_->paintConfig_->dstRect_ = srcRect_;
830 imagePainter.DrawImageWithRepeat(testingCanvas, CONTENTRECT);
831 EXPECT_EQ(CONTENTRECT.Width(), 1);
832 EXPECT_EQ(CONTENTRECT.Height(), 1);
833 }
834
835 /**
836 * @tc.name: ImagePainterTestNg_CalculateBgWidth13
837 * @tc.desc: Test cast to CalculateBgWidth
838 * @tc.type: FUNC
839 */
840 HWTEST_F(ImagePainterTestNg, ImagePainterTestNg_CalculateBgImageSize13, TestSize.Level1)
841 {
842 srcSize = { 2, 1 };
843 BackgroundImageSize backgroundImageSize(
844 BackgroundImageSizeType::PERCENT, 100, BackgroundImageSizeType::PERCENT, 100);
845 const std::optional<BackgroundImageSize>& bgImageSizeOpt = backgroundImageSize;
846 auto sizeRet = NG::ImagePainter::CalculateBgImageSize(boxPaintSize_, srcSize, bgImageSizeOpt);
847 EXPECT_EQ(boxPaintSize_.Width() * bgImageSizeOpt.value().GetSizeValueX() * srcSize.Width() / srcSize.Height(),
848 sizeRet.Width() * 100);
849
850 BackgroundImageSize backgroundImageSize1(BackgroundImageSizeType::AUTO, 100, BackgroundImageSizeType::PERCENT, 100);
851 const std::optional<BackgroundImageSize>& bgImageSizeOpt1 = backgroundImageSize1;
852 auto sizeRet_ = NG::ImagePainter::CalculateBgImageSize(boxPaintSize_, srcSize, bgImageSizeOpt1);
853 EXPECT_EQ(boxPaintSize_.Width() * bgImageSizeOpt.value().GetSizeValueX() * srcSize.Width() / srcSize.Height(),
854 sizeRet_.Width() * 100);
855 }
856
857 /**
858 * @tc.name: ImagePainterTestNg_CalculateBgImagePosition14
859 * @tc.desc: Test cast to CalculateBgImagePosition
860 * @tc.type: FUNC
861 */
862 HWTEST_F(ImagePainterTestNg, ImagePainterTestNg_CalculateBgImagePosition14, TestSize.Level1)
863 {
864 RefPtr<NG::CanvasImage> canvasImage;
865 NG::ImagePainter imagePainter(canvasImage);
866 const NG::SizeF boxPaintSize_;
867 const NG::SizeF imageRenderSize_;
868
869 BackgroundImagePosition backgroundImagePosition(
870 BackgroundImagePositionType::PX, 1, BackgroundImagePositionType::PX, 1);
871 std::optional<BackgroundImagePosition> bgImgPositionOpt = backgroundImagePosition;
872 bgImgPositionOpt.value().SetIsAlign(true);
873 auto offset = imagePainter.CalculateBgImagePosition(boxPaintSize_, imageRenderSize_, bgImgPositionOpt);
874 EXPECT_EQ(offset.GetX(), 0);
875 EXPECT_EQ(offset.GetY(), 0);
876 }
877
878 /**
879 * @tc.name: ImagePainterTestNg_ApplyImageAlignmentFit15
880 * @tc.desc: Test cast to CirclePainterTestNg
881 * @tc.type: FUNC
882 */
883 HWTEST_F(ImagePainterTestNg, ImagePainterTestNg_ApplyImageAlignmentFit15, TestSize.Level1)
884 {
885 /**
886 * @tc.steps1: build a imagePainter object.
887 */
888 RefPtr<NG::CanvasImage> canvasImage;
889 NG::ImagePainter imagePainter(canvasImage);
890 NG::RectF srcRect_;
891 NG::RectF dstRect_;
892
893 /**
894 * @tc.steps2: callback ApplyImageAlignmentFit when ImageFit::FILL
895 * @tc.expected: not find.
896 */
897 imagePainter.ApplyImageAlignmentFit(ImageFit::FILL, rawpicsize, dstsize, srcRect_, dstRect_);
898 auto itImageFit = imagePainter.ALIMENT_OPERATIONS.find(ImageFit::FILL);
899 EXPECT_EQ(itImageFit, imagePainter.ALIMENT_OPERATIONS.end());
900
901 /**
902 * @tc.steps3: callback ApplyImageAlignmentFit when ImageFit::TOP_LEFT.
903 * @tc.expected: find.
904 */
905 imagePainter.ApplyImageAlignmentFit(ImageFit::TOP_LEFT, rawpicsize, dstsize, srcRect_, dstRect_);
906 auto itImageFit_ = imagePainter.ALIMENT_OPERATIONS.find(ImageFit::TOP_LEFT);
907 EXPECT_NE(itImageFit_, imagePainter.ALIMENT_OPERATIONS.end());
908 }
909
910 /**
911 * @tc.name: ImagePainterTestNg_ApplyImageFit16
912 * @tc.desc: Test cast to ApplyImageFit
913 * @tc.type: FUNC
914 */
915 HWTEST_F(ImagePainterTestNg, ImagePainterTestNg_ApplyImageFit16, TestSize.Level1)
916 {
917 /**
918 * @tc.steps1: build a imagePainter object.
919 */
920 RefPtr<NG::CanvasImage> canvasImage;
921 NG::ImagePainter imagePainter(canvasImage);
922 NG::RectF srcRect_(1.0f, 1.0f, 2.0f, 2.0f);
923 NG::RectF dstRect_(1.0f, 1.0f, 1.0f, 1.0f);
924 NG::RectF dstRect(1.0f, 1.0f, 2.0f, 2.0f);
925
926 /**
927 * @tc.steps2: callback ApplyImageFit.
928 * @tc.expected: expect ImageFit is COVER_TOP_LEFT.
929 */
930 imagePainter.ApplyImageFit(ImageFit::COVER_TOP_LEFT, rawpicsize, dstsize, srcRect_, dstRect_);
931 auto itImageFit = imagePainter.ALIMENT_OPERATIONS.find(ImageFit::COVER_TOP_LEFT);
932 EXPECT_EQ(itImageFit, imagePainter.ALIMENT_OPERATIONS.end());
933
934 imagePainter.ApplyImageFit(ImageFit::END, rawpicsize, dstsize, srcRect_, dstRect_);
935 auto itImageFit1 = imagePainter.ALIMENT_OPERATIONS.find(ImageFit::END);
936 EXPECT_NE(itImageFit1, imagePainter.ALIMENT_OPERATIONS.end());
937
938 /**
939 * @tc.steps2: callback ApplyImageFit.
940 * @tc.expected: expect ImageFit is SCALE_DOWN,srcRect_=dstRect_.
941 */
942 imagePainter.ApplyImageFit(ImageFit::SCALE_DOWN, rawpicsize, dstsize, srcRect_, dstRect);
943 EXPECT_NE(srcRect_.GetSize() > dstRect.GetSize(), true);
944 }
945
946 /**
947 * @tc.name: ImagePainterTestNg_ApplyImageAlignmentFit17
948 * @tc.desc: Test cast to ApplyImageAlignmentFit
949 * @tc.type: FUNC
950 */
951 HWTEST_F(ImagePainterTestNg, ImagePainterTestNg_ApplyImageAlignmentFit17, TestSize.Level1)
952 {
953 /**
954 * @tc.steps1: build a imagePainter object.
955 */
956 RefPtr<NG::CanvasImage> canvasImage;
957 NG::ImagePainter imagePainter(canvasImage);
958 NG::RectF srcRect_;
959 NG::RectF dstRect_;
960
961 /**
962 * @tc.steps2: callback ApplyImageAlignmentFit when ImageFit::TOP_END.
963 * @tc.expected: find && isRightToLeft_ = false.
964 */
965 imagePainter.ApplyImageAlignmentFit(ImageFit::TOP_END, rawpicsize, dstsize, srcRect_, dstRect_);
966 auto itImageFit1 = imagePainter.ALIMENT_OPERATIONS.find(ImageFit::TOP_END);
967 EXPECT_NE(itImageFit1, imagePainter.ALIMENT_OPERATIONS.end());
968
969 /**
970 * @tc.steps3: callback ApplyImageAlignmentFit when ImageFit::START.
971 * @tc.expected: find && isRightToLeft_ = false.
972 */
973 imagePainter.ApplyImageAlignmentFit(ImageFit::START, rawpicsize, dstsize, srcRect_, dstRect_);
974 auto itImageFit2 = imagePainter.ALIMENT_OPERATIONS.find(ImageFit::START);
975 EXPECT_NE(itImageFit2, imagePainter.ALIMENT_OPERATIONS.end());
976
977 /**
978 * @tc.steps4: callback ApplyImageAlignmentFit when ImageFit::END.
979 * @tc.expected: find && isRightToLeft_ = false.
980 */
981 imagePainter.ApplyImageAlignmentFit(ImageFit::END, rawpicsize, dstsize, srcRect_, dstRect_);
982 auto itImageFit3 = imagePainter.ALIMENT_OPERATIONS.find(ImageFit::END);
983 EXPECT_NE(itImageFit3, imagePainter.ALIMENT_OPERATIONS.end());
984
985 /**
986 * @tc.steps5: callback ApplyImageAlignmentFit when ImageFit::BOTTOM_START.
987 * @tc.expected: find && isRightToLeft_ = false.
988 */
989 imagePainter.ApplyImageAlignmentFit(ImageFit::BOTTOM_START, rawpicsize, dstsize, srcRect_, dstRect_);
990 auto itImageFit4 = imagePainter.ALIMENT_OPERATIONS.find(ImageFit::BOTTOM_START);
991 EXPECT_NE(itImageFit4, imagePainter.ALIMENT_OPERATIONS.end());
992
993 /**
994 * @tc.steps6: callback ApplyImageAlignmentFit when ImageFit::BOTTOM_END.
995 * @tc.expected: find && isRightToLeft_ = false.
996 */
997 imagePainter.ApplyImageAlignmentFit(ImageFit::BOTTOM_END, rawpicsize, dstsize, srcRect_, dstRect_);
998 auto itImageFit5 = imagePainter.ALIMENT_OPERATIONS.find(ImageFit::BOTTOM_END);
999 EXPECT_NE(itImageFit5, imagePainter.ALIMENT_OPERATIONS.end());
1000 }
1001
1002 /**
1003 * @tc.name: ImagePainterTestNg_ApplyImageAlignmentFit18
1004 * @tc.desc: Test cast to ApplyImageAlignmentFit
1005 * @tc.type: FUNC
1006 */
1007 HWTEST_F(ImagePainterTestNg, ImagePainterTestNg_ApplyImageAlignmentFit18, TestSize.Level1)
1008 {
1009 /**
1010 * @tc.steps1: build a imagePainter object.
1011 */
1012 RefPtr<NG::CanvasImage> canvasImage;
1013 NG::ImagePainter imagePainter(canvasImage);
1014 NG::RectF srcRect_;
1015 NG::RectF dstRect_;
1016
1017 /**
1018 * @tc.steps2: callback ApplyImageAlignmentFit when ImageFit::TOP_LEFT,ImageFit::TOP_END...
1019 * @tc.expected: find && isRightToLeft_ = true.
1020 */
1021 AceApplicationInfo::GetInstance().isRightToLeft_ = true;
1022 imagePainter.ApplyImageAlignmentFit(ImageFit::TOP_LEFT, rawpicsize, dstsize, srcRect_, dstRect_);
1023 auto itImageFit_ = imagePainter.ALIMENT_OPERATIONS.find(ImageFit::TOP_LEFT);
1024 EXPECT_NE(itImageFit_, imagePainter.ALIMENT_OPERATIONS.end());
1025 EXPECT_EQ(itImageFit_->second(AceApplicationInfo::GetInstance().isRightToLeft_), Alignment::TOP_RIGHT);
1026
1027 imagePainter.ApplyImageAlignmentFit(ImageFit::TOP_END, rawpicsize, dstsize, srcRect_, dstRect_);
1028 auto itImageFit1 = imagePainter.ALIMENT_OPERATIONS.find(ImageFit::TOP_END);
1029 EXPECT_NE(itImageFit1, imagePainter.ALIMENT_OPERATIONS.end());
1030 EXPECT_EQ(itImageFit1->second(AceApplicationInfo::GetInstance().isRightToLeft_), Alignment::TOP_LEFT);
1031
1032 imagePainter.ApplyImageAlignmentFit(ImageFit::START, rawpicsize, dstsize, srcRect_, dstRect_);
1033 auto itImageFit2 = imagePainter.ALIMENT_OPERATIONS.find(ImageFit::START);
1034 EXPECT_NE(itImageFit2, imagePainter.ALIMENT_OPERATIONS.end());
1035 EXPECT_EQ(itImageFit2->second(AceApplicationInfo::GetInstance().isRightToLeft_), Alignment::CENTER_RIGHT);
1036
1037 imagePainter.ApplyImageAlignmentFit(ImageFit::END, rawpicsize, dstsize, srcRect_, dstRect_);
1038 auto itImageFit3 = imagePainter.ALIMENT_OPERATIONS.find(ImageFit::END);
1039 EXPECT_NE(itImageFit3, imagePainter.ALIMENT_OPERATIONS.end());
1040 EXPECT_EQ(itImageFit3->second(AceApplicationInfo::GetInstance().isRightToLeft_), Alignment::CENTER_LEFT);
1041
1042 imagePainter.ApplyImageAlignmentFit(ImageFit::BOTTOM_START, rawpicsize, dstsize, srcRect_, dstRect_);
1043 auto itImageFit4 = imagePainter.ALIMENT_OPERATIONS.find(ImageFit::BOTTOM_START);
1044 EXPECT_NE(itImageFit4, imagePainter.ALIMENT_OPERATIONS.end());
1045 EXPECT_EQ(itImageFit4->second(AceApplicationInfo::GetInstance().isRightToLeft_), Alignment::BOTTOM_RIGHT);
1046
1047 imagePainter.ApplyImageAlignmentFit(ImageFit::BOTTOM_END, rawpicsize, dstsize, srcRect_, dstRect_);
1048 auto itImageFit5 = imagePainter.ALIMENT_OPERATIONS.find(ImageFit::BOTTOM_END);
1049 EXPECT_NE(itImageFit5, imagePainter.ALIMENT_OPERATIONS.end());
1050 EXPECT_EQ(itImageFit5->second(AceApplicationInfo::GetInstance().isRightToLeft_), Alignment::BOTTOM_LEFT);
1051 }
1052 } // namespace OHOS::Ace
1053