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_TestDrawingClamp
806 * @tc.desc: Test cast to DrawingClamp
807 * @tc.type: FUNC
808 */
809 HWTEST_F(ImagePainterTestNg, ImagePainterTestNg_TestDrawingClamp, TestSize.Level1)
810 {
811 RSClamp rsClamp = Testing::TestingClamp::NO_CLAMP;
812 EXPECT_EQ(rsClamp, Testing::TestingClamp::NO_CLAMP);
813 rsClamp = Testing::TestingClamp::YES_CLAMP;
814 EXPECT_EQ(rsClamp, Testing::TestingClamp::YES_CLAMP);
815 }
816
817 /**
818 * @tc.name: ImagePainterTestNg_DrawImageWithRepeat12
819 * @tc.desc: Test cast to CirclePainterTestNg
820 * @tc.type: FUNC
821 */
822 HWTEST_F(ImagePainterTestNg, ImagePainterTestNg_DrawImageWithRepeat12, TestSize.Level1)
823 {
824 /**
825 * @tc.steps1: build a imagePainter object.
826 */
827 RefPtr<NG::CanvasImage> canvasImage;
828 NG::ImagePainter imagePainter(canvasImage);
829 NG::ImagePaintConfig imagePaintConfig;
830
831 /**
832 * @tc.steps2 build a pixelMapImage object.
833 */
834 imagePainter.canvasImage_ = AceType::MakeRefPtr<NG::MockCanvasImage>();
835 imagePainter.canvasImage_->paintConfig_ = std::make_unique<NG::ImagePaintConfig>();
836 NG::RectF srcRect_(1.0f, 1.0f, 0.0001f, 0.0001f);
837
838 /**
839 * @tc.steps3callback DrawImageWithRepeat.
840 * @tc.expected: expect NearZero(singleImageHeight).
841 */
842 imagePainter.canvasImage_->paintConfig_->dstRect_ = srcRect_;
843 imagePainter.DrawImageWithRepeat(testingCanvas, CONTENTRECT);
844 EXPECT_EQ(CONTENTRECT.Width(), 1);
845 EXPECT_EQ(CONTENTRECT.Height(), 1);
846 }
847
848 /**
849 * @tc.name: ImagePainterTestNg_CalculateBgWidth13
850 * @tc.desc: Test cast to CalculateBgWidth
851 * @tc.type: FUNC
852 */
853 HWTEST_F(ImagePainterTestNg, ImagePainterTestNg_CalculateBgImageSize13, TestSize.Level1)
854 {
855 srcSize = { 2, 1 };
856 BackgroundImageSize backgroundImageSize(
857 BackgroundImageSizeType::PERCENT, 100, BackgroundImageSizeType::PERCENT, 100);
858 const std::optional<BackgroundImageSize>& bgImageSizeOpt = backgroundImageSize;
859 auto sizeRet = NG::ImagePainter::CalculateBgImageSize(boxPaintSize_, srcSize, bgImageSizeOpt);
860 EXPECT_EQ(boxPaintSize_.Width() * bgImageSizeOpt.value().GetSizeValueX() * srcSize.Width() / srcSize.Height(),
861 sizeRet.Width() * 100);
862
863 BackgroundImageSize backgroundImageSize1(BackgroundImageSizeType::AUTO, 100, BackgroundImageSizeType::PERCENT, 100);
864 const std::optional<BackgroundImageSize>& bgImageSizeOpt1 = backgroundImageSize1;
865 auto sizeRet_ = NG::ImagePainter::CalculateBgImageSize(boxPaintSize_, srcSize, bgImageSizeOpt1);
866 EXPECT_EQ(boxPaintSize_.Width() * bgImageSizeOpt.value().GetSizeValueX() * srcSize.Width() / srcSize.Height(),
867 sizeRet_.Width() * 100);
868 }
869
870 /**
871 * @tc.name: ImagePainterTestNg_CalculateBgImagePosition14
872 * @tc.desc: Test cast to CalculateBgImagePosition
873 * @tc.type: FUNC
874 */
875 HWTEST_F(ImagePainterTestNg, ImagePainterTestNg_CalculateBgImagePosition14, TestSize.Level1)
876 {
877 RefPtr<NG::CanvasImage> canvasImage;
878 NG::ImagePainter imagePainter(canvasImage);
879 const NG::SizeF boxPaintSize_;
880 const NG::SizeF imageRenderSize_;
881
882 BackgroundImagePosition backgroundImagePosition(
883 BackgroundImagePositionType::PX, 1, BackgroundImagePositionType::PX, 1);
884 std::optional<BackgroundImagePosition> bgImgPositionOpt = backgroundImagePosition;
885 bgImgPositionOpt.value().SetIsAlign(true);
886 auto offset = imagePainter.CalculateBgImagePosition(boxPaintSize_, imageRenderSize_, bgImgPositionOpt);
887 EXPECT_EQ(offset.GetX(), 0);
888 EXPECT_EQ(offset.GetY(), 0);
889 }
890
891 /**
892 * @tc.name: ImagePainterTestNg_ApplyImageAlignmentFit15
893 * @tc.desc: Test cast to CirclePainterTestNg
894 * @tc.type: FUNC
895 */
896 HWTEST_F(ImagePainterTestNg, ImagePainterTestNg_ApplyImageAlignmentFit15, TestSize.Level1)
897 {
898 /**
899 * @tc.steps1: build a imagePainter object.
900 */
901 RefPtr<NG::CanvasImage> canvasImage;
902 NG::ImagePainter imagePainter(canvasImage);
903 NG::RectF srcRect_;
904 NG::RectF dstRect_;
905
906 /**
907 * @tc.steps2: callback ApplyImageAlignmentFit when ImageFit::FILL
908 * @tc.expected: not find.
909 */
910 imagePainter.ApplyImageAlignmentFit(ImageFit::FILL, rawpicsize, dstsize, srcRect_, dstRect_);
911 auto itImageFit = imagePainter.ALIMENT_OPERATIONS.find(ImageFit::FILL);
912 EXPECT_EQ(itImageFit, imagePainter.ALIMENT_OPERATIONS.end());
913
914 /**
915 * @tc.steps3: callback ApplyImageAlignmentFit when ImageFit::TOP_LEFT.
916 * @tc.expected: find.
917 */
918 imagePainter.ApplyImageAlignmentFit(ImageFit::TOP_LEFT, rawpicsize, dstsize, srcRect_, dstRect_);
919 auto itImageFit_ = imagePainter.ALIMENT_OPERATIONS.find(ImageFit::TOP_LEFT);
920 EXPECT_NE(itImageFit_, imagePainter.ALIMENT_OPERATIONS.end());
921 }
922
923 /**
924 * @tc.name: ImagePainterTestNg_ApplyImageFit16
925 * @tc.desc: Test cast to ApplyImageFit
926 * @tc.type: FUNC
927 */
928 HWTEST_F(ImagePainterTestNg, ImagePainterTestNg_ApplyImageFit16, TestSize.Level1)
929 {
930 /**
931 * @tc.steps1: build a imagePainter object.
932 */
933 RefPtr<NG::CanvasImage> canvasImage;
934 NG::ImagePainter imagePainter(canvasImage);
935 NG::RectF srcRect_(1.0f, 1.0f, 2.0f, 2.0f);
936 NG::RectF dstRect_(1.0f, 1.0f, 1.0f, 1.0f);
937 NG::RectF dstRect(1.0f, 1.0f, 2.0f, 2.0f);
938
939 /**
940 * @tc.steps2: callback ApplyImageFit.
941 * @tc.expected: expect ImageFit is COVER_TOP_LEFT.
942 */
943 imagePainter.ApplyImageFit(ImageFit::COVER_TOP_LEFT, rawpicsize, dstsize, srcRect_, dstRect_);
944 auto itImageFit = imagePainter.ALIMENT_OPERATIONS.find(ImageFit::COVER_TOP_LEFT);
945 EXPECT_EQ(itImageFit, imagePainter.ALIMENT_OPERATIONS.end());
946
947 imagePainter.ApplyImageFit(ImageFit::END, rawpicsize, dstsize, srcRect_, dstRect_);
948 auto itImageFit1 = imagePainter.ALIMENT_OPERATIONS.find(ImageFit::END);
949 EXPECT_NE(itImageFit1, imagePainter.ALIMENT_OPERATIONS.end());
950
951 /**
952 * @tc.steps2: callback ApplyImageFit.
953 * @tc.expected: expect ImageFit is SCALE_DOWN,srcRect_=dstRect_.
954 */
955 imagePainter.ApplyImageFit(ImageFit::SCALE_DOWN, rawpicsize, dstsize, srcRect_, dstRect);
956 EXPECT_NE(srcRect_.GetSize() > dstRect.GetSize(), true);
957 }
958
959 /**
960 * @tc.name: ImagePainterTestNg_ApplyImageAlignmentFit17
961 * @tc.desc: Test cast to ApplyImageAlignmentFit
962 * @tc.type: FUNC
963 */
964 HWTEST_F(ImagePainterTestNg, ImagePainterTestNg_ApplyImageAlignmentFit17, TestSize.Level1)
965 {
966 /**
967 * @tc.steps1: build a imagePainter object.
968 */
969 RefPtr<NG::CanvasImage> canvasImage;
970 NG::ImagePainter imagePainter(canvasImage);
971 NG::RectF srcRect_;
972 NG::RectF dstRect_;
973
974 /**
975 * @tc.steps2: callback ApplyImageAlignmentFit when ImageFit::TOP_END.
976 * @tc.expected: find && isRightToLeft_ = false.
977 */
978 imagePainter.ApplyImageAlignmentFit(ImageFit::TOP_END, rawpicsize, dstsize, srcRect_, dstRect_);
979 auto itImageFit1 = imagePainter.ALIMENT_OPERATIONS.find(ImageFit::TOP_END);
980 EXPECT_NE(itImageFit1, imagePainter.ALIMENT_OPERATIONS.end());
981
982 /**
983 * @tc.steps3: callback ApplyImageAlignmentFit when ImageFit::START.
984 * @tc.expected: find && isRightToLeft_ = false.
985 */
986 imagePainter.ApplyImageAlignmentFit(ImageFit::START, rawpicsize, dstsize, srcRect_, dstRect_);
987 auto itImageFit2 = imagePainter.ALIMENT_OPERATIONS.find(ImageFit::START);
988 EXPECT_NE(itImageFit2, imagePainter.ALIMENT_OPERATIONS.end());
989
990 /**
991 * @tc.steps4: callback ApplyImageAlignmentFit when ImageFit::END.
992 * @tc.expected: find && isRightToLeft_ = false.
993 */
994 imagePainter.ApplyImageAlignmentFit(ImageFit::END, rawpicsize, dstsize, srcRect_, dstRect_);
995 auto itImageFit3 = imagePainter.ALIMENT_OPERATIONS.find(ImageFit::END);
996 EXPECT_NE(itImageFit3, imagePainter.ALIMENT_OPERATIONS.end());
997
998 /**
999 * @tc.steps5: callback ApplyImageAlignmentFit when ImageFit::BOTTOM_START.
1000 * @tc.expected: find && isRightToLeft_ = false.
1001 */
1002 imagePainter.ApplyImageAlignmentFit(ImageFit::BOTTOM_START, rawpicsize, dstsize, srcRect_, dstRect_);
1003 auto itImageFit4 = imagePainter.ALIMENT_OPERATIONS.find(ImageFit::BOTTOM_START);
1004 EXPECT_NE(itImageFit4, imagePainter.ALIMENT_OPERATIONS.end());
1005
1006 /**
1007 * @tc.steps6: callback ApplyImageAlignmentFit when ImageFit::BOTTOM_END.
1008 * @tc.expected: find && isRightToLeft_ = false.
1009 */
1010 imagePainter.ApplyImageAlignmentFit(ImageFit::BOTTOM_END, rawpicsize, dstsize, srcRect_, dstRect_);
1011 auto itImageFit5 = imagePainter.ALIMENT_OPERATIONS.find(ImageFit::BOTTOM_END);
1012 EXPECT_NE(itImageFit5, imagePainter.ALIMENT_OPERATIONS.end());
1013 }
1014
1015 /**
1016 * @tc.name: ImagePainterTestNg_ApplyImageAlignmentFit18
1017 * @tc.desc: Test cast to ApplyImageAlignmentFit
1018 * @tc.type: FUNC
1019 */
1020 HWTEST_F(ImagePainterTestNg, ImagePainterTestNg_ApplyImageAlignmentFit18, TestSize.Level1)
1021 {
1022 /**
1023 * @tc.steps1: build a imagePainter object.
1024 */
1025 RefPtr<NG::CanvasImage> canvasImage;
1026 NG::ImagePainter imagePainter(canvasImage);
1027 NG::RectF srcRect_;
1028 NG::RectF dstRect_;
1029
1030 /**
1031 * @tc.steps2: callback ApplyImageAlignmentFit when ImageFit::TOP_LEFT,ImageFit::TOP_END...
1032 * @tc.expected: find && isRightToLeft_ = true.
1033 */
1034 AceApplicationInfo::GetInstance().isRightToLeft_ = true;
1035 imagePainter.ApplyImageAlignmentFit(ImageFit::TOP_LEFT, rawpicsize, dstsize, srcRect_, dstRect_);
1036 auto itImageFit_ = imagePainter.ALIMENT_OPERATIONS.find(ImageFit::TOP_LEFT);
1037 EXPECT_NE(itImageFit_, imagePainter.ALIMENT_OPERATIONS.end());
1038 EXPECT_EQ(itImageFit_->second(AceApplicationInfo::GetInstance().isRightToLeft_), Alignment::TOP_RIGHT);
1039
1040 imagePainter.ApplyImageAlignmentFit(ImageFit::TOP_END, rawpicsize, dstsize, srcRect_, dstRect_);
1041 auto itImageFit1 = imagePainter.ALIMENT_OPERATIONS.find(ImageFit::TOP_END);
1042 EXPECT_NE(itImageFit1, imagePainter.ALIMENT_OPERATIONS.end());
1043 EXPECT_EQ(itImageFit1->second(AceApplicationInfo::GetInstance().isRightToLeft_), Alignment::TOP_LEFT);
1044
1045 imagePainter.ApplyImageAlignmentFit(ImageFit::START, rawpicsize, dstsize, srcRect_, dstRect_);
1046 auto itImageFit2 = imagePainter.ALIMENT_OPERATIONS.find(ImageFit::START);
1047 EXPECT_NE(itImageFit2, imagePainter.ALIMENT_OPERATIONS.end());
1048 EXPECT_EQ(itImageFit2->second(AceApplicationInfo::GetInstance().isRightToLeft_), Alignment::CENTER_RIGHT);
1049
1050 imagePainter.ApplyImageAlignmentFit(ImageFit::END, rawpicsize, dstsize, srcRect_, dstRect_);
1051 auto itImageFit3 = imagePainter.ALIMENT_OPERATIONS.find(ImageFit::END);
1052 EXPECT_NE(itImageFit3, imagePainter.ALIMENT_OPERATIONS.end());
1053 EXPECT_EQ(itImageFit3->second(AceApplicationInfo::GetInstance().isRightToLeft_), Alignment::CENTER_LEFT);
1054
1055 imagePainter.ApplyImageAlignmentFit(ImageFit::BOTTOM_START, rawpicsize, dstsize, srcRect_, dstRect_);
1056 auto itImageFit4 = imagePainter.ALIMENT_OPERATIONS.find(ImageFit::BOTTOM_START);
1057 EXPECT_NE(itImageFit4, imagePainter.ALIMENT_OPERATIONS.end());
1058 EXPECT_EQ(itImageFit4->second(AceApplicationInfo::GetInstance().isRightToLeft_), Alignment::BOTTOM_RIGHT);
1059
1060 imagePainter.ApplyImageAlignmentFit(ImageFit::BOTTOM_END, rawpicsize, dstsize, srcRect_, dstRect_);
1061 auto itImageFit5 = imagePainter.ALIMENT_OPERATIONS.find(ImageFit::BOTTOM_END);
1062 EXPECT_NE(itImageFit5, imagePainter.ALIMENT_OPERATIONS.end());
1063 EXPECT_EQ(itImageFit5->second(AceApplicationInfo::GetInstance().isRightToLeft_), Alignment::BOTTOM_LEFT);
1064 }
1065
1066 /**
1067 * @tc.name: ImagePainterTestNg_DrawingClamp
1068 * @tc.desc: Test cast to DrawingClamp
1069 * @tc.type: FUNC
1070 */
1071 HWTEST_F(ImagePainterTestNg, ImagePainterTestNg_DrawingClamp, TestSize.Level1)
1072 {
1073 RSClamp rsClamp = Testing::TestingClamp::NO_CLAMP;
1074 EXPECT_EQ(rsClamp, Testing::TestingClamp::NO_CLAMP);
1075 rsClamp = Testing::TestingClamp::YES_CLAMP;
1076 EXPECT_EQ(rsClamp, Testing::TestingClamp::YES_CLAMP);
1077 }
1078 } // namespace OHOS::Ace
1079