1 /*
2  * Copyright (c) 2022 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "gtest/gtest.h"
17 #include "message_parcel.h"
18 #include "pixel_map.h"
19 #include "skia_canvas.h"
20 
21 #include "draw/surface.h"
22 #include "render/rs_image.h"
23 #include "render/rs_image_cache.h"
24 #include "transaction/rs_marshalling_helper.h"
25 
26 using namespace testing;
27 using namespace testing::ext;
28 
29 namespace OHOS::Rosen {
30 class RSImageTest : public testing::Test {
31 public:
32     static void SetUpTestCase();
33     static void TearDownTestCase();
34     void SetUp() override;
35     void TearDown() override;
36 };
37 
SetUpTestCase()38 void RSImageTest::SetUpTestCase() {}
TearDownTestCase()39 void RSImageTest::TearDownTestCase() {}
SetUp()40 void RSImageTest::SetUp() {}
TearDown()41 void RSImageTest::TearDown() {}
42 
43 /**
44  * @tc.name: IsEqual001
45  * @tc.desc:
46  * @tc.type:FUNC
47  */
48 HWTEST_F(RSImageTest, IsEqual001, TestSize.Level1)
49 {
50     /**
51      * @tc.steps: step1. create RSMask by Gradient
52      */
53     RSImage rsImage;
54     int res = rsImage.IsEqual(rsImage);
55     ASSERT_TRUE(res);
56     RSImage other;
57     other.SetScale(2.f);
58     res = rsImage.IsEqual(other);
59     ASSERT_FALSE(res);
60 }
61 
CreatePixelMap(int width,int height)62 static std::shared_ptr<Media::PixelMap> CreatePixelMap(int width, int height)
63 {
64     Media::InitializationOptions opts;
65     opts.size.width = width;
66     opts.size.height = height;
67     auto pixelmap = Media::PixelMap::Create(opts);
68     auto address = const_cast<uint32_t*>(pixelmap->GetPixel32(0, 0));
69     if (address == nullptr) {
70         return nullptr;
71     }
72     Drawing::ImageInfo info = Drawing::ImageInfo(
73         pixelmap->GetWidth(), pixelmap->GetHeight(), Drawing::COLORTYPE_RGBA_8888, Drawing::ALPHATYPE_PREMUL);
74     auto surface = Drawing::Surface::MakeRasterDirect(info, address, pixelmap->GetRowBytes());
75     auto canvas = surface->GetCanvas();
76     canvas->Clear(Drawing::Color::COLOR_YELLOW);
77     Drawing::Brush brush;
78     brush.SetColor(Drawing::Color::COLOR_RED);
79     canvas->AttachBrush(brush);
80     canvas->DrawRect(Drawing::Rect(width / 4, height / 4, width / 2, height / 2));
81     canvas->DetachBrush();
82     return pixelmap;
83 }
84 
85 /**
86  * @tc.name: LifeCycle001
87  * @tc.desc:
88  * @tc.type:FUNC
89  */
90 HWTEST_F(RSImageTest, LifeCycle001, TestSize.Level1)
91 {
92     /**
93      * @tc.steps: step1. create RSMask by Gradient
94      */
95     RSImage rsImage;
96     Drawing::Canvas drawingCanvas;
97     RSPaintFilterCanvas canvas(&drawingCanvas);
98     float fLeft = 1.0f;
99     float ftop = 1.0f;
100     float fRight = 1.0f;
101     float fBottom = 1.0f;
102     rsImage.SetImageFit(0);
103     Drawing::Rect rect { fLeft, ftop, fRight, fBottom };
104     Drawing::Brush brush;
105     std::shared_ptr<Media::PixelMap> pixelmap;
106     ASSERT_EQ(pixelmap, nullptr);
107     rsImage.SetPixelMap(pixelmap);
108     int width = 200;
109     int height = 300;
110     pixelmap = CreatePixelMap(width, height);
111     rsImage.SetPixelMap(pixelmap);
112     canvas.AttachBrush(brush);
113     rsImage.CanvasDrawImage(canvas, rect, Drawing::SamplingOptions(), false);
114     rsImage.CanvasDrawImage(canvas, rect, Drawing::SamplingOptions(), true);
115     rsImage.SetImageFit(1);
116     rsImage.CanvasDrawImage(canvas, rect, Drawing::SamplingOptions(), true);
117     rsImage.SetImageFit(2);
118     rsImage.CanvasDrawImage(canvas, rect, Drawing::SamplingOptions(), true);
119     rsImage.SetImageFit(3);
120     rsImage.CanvasDrawImage(canvas, rect, Drawing::SamplingOptions(), true);
121     rsImage.SetImageFit(4);
122     rsImage.CanvasDrawImage(canvas, rect, Drawing::SamplingOptions(), true);
123     rsImage.SetImageFit(5);
124     rsImage.CanvasDrawImage(canvas, rect, Drawing::SamplingOptions(), true);
125     rsImage.SetImageFit(6);
126     rsImage.CanvasDrawImage(canvas, rect, Drawing::SamplingOptions(), true);
127     rsImage.SetImageFit(0);
128     rsImage.CanvasDrawImage(canvas, rect, Drawing::SamplingOptions(), true);
129     rsImage.SetImageFit(8);
130     rsImage.CanvasDrawImage(canvas, rect, Drawing::SamplingOptions(), true);
131     canvas.DetachBrush();
132 }
133 
134 /**
135  * @tc.name: CanvasDrawImageTest
136  * @tc.desc: test results of CanvasDrawImage
137  * @tc.type: FUNC
138  * @tc.require: issuesI9TOXM
139  */
140 HWTEST_F(RSImageTest, CanvasDrawImageTest, TestSize.Level1)
141 {
142     RSImage rsImage;
143     Drawing::Canvas canvas;
144     canvas.recordingState_ = true;
145     Drawing::Rect rect { 1.0f, 1.0f, 1.0f, 1.0f };
146     Drawing::Brush brush;
147     // for test
148     std::shared_ptr<Media::PixelMap> pixelmap = CreatePixelMap(200, 300);
149     ASSERT_NE(pixelmap, nullptr);
150     Drawing::SamplingOptions samplingOptions;
151     rsImage.pixelMap_ = pixelmap;
152     rsImage.pixelMap_->SetAstc(true);
153     rsImage.image_ = std::make_shared<Drawing::Image>();
154     rsImage.CanvasDrawImage(canvas, rect, samplingOptions, false);
155     // for test
156     rsImage.innerRect_ = Drawing::RectI { 0, 0, 10, 10 };
157     rsImage.CanvasDrawImage(canvas, rect, samplingOptions, false);
158 }
159 
160 /**
161  * @tc.name: ApplyImageFitTest001
162  * @tc.desc: Verify function ApplyImageFit
163  * @tc.type:FUNC
164  */
165 HWTEST_F(RSImageTest, ApplyImageFitTest001, TestSize.Level1)
166 {
167     auto image = std::make_shared<RSImage>();
168     RectF srcRf(0.f, 0.f, 0.f, 0.f);
169     image->srcRect_ = srcRf;
170     image->imageFit_ = ImageFit::TOP_LEFT;
171     image->ApplyImageFit();
172     EXPECT_EQ(image->srcRect_.width_, 0);
173     RectF srcRs(1.f, 1.f, 1.f, 1.f);
174     image->srcRect_ = srcRs;
175     image->ApplyImageFit();
176     EXPECT_EQ(image->srcRect_.width_, 1);
177     image->scale_ = 0;
178     image->imageFit_ = ImageFit::NONE;
179     image->ApplyImageFit();
180     image->imageFit_ = ImageFit::FIT_WIDTH;
181     image->ApplyImageFit();
182     image->imageFit_ = ImageFit::FIT_HEIGHT;
183     image->ApplyImageFit();
184     image->imageFit_ = ImageFit::SCALE_DOWN;
185     image->ApplyImageFit();
186     EXPECT_EQ(image->srcRect_.width_, 1);
187 }
188 
189 /**
190  * @tc.name: GetAdaptiveImageInfoWithFrameRectTest001
191  * @tc.desc: Verify function GetAdaptiveImageInfoWithFrameRect
192  * @tc.type:FUNC
193  */
194 HWTEST_F(RSImageTest, GetAdaptiveImageInfoWithFrameRectTest001, TestSize.Level1)
195 {
196     Drawing::Rect frameRect;
197     auto image = std::make_shared<RSImage>();
198     image->imageFit_ = ImageFit::COVER;
199     EXPECT_EQ(
200         image->GetAdaptiveImageInfoWithCustomizedFrameRect(frameRect).fitNum, static_cast<int32_t>(ImageFit::COVER));
201 }
202 
203 /**
204  * @tc.name: ApplyCanvasClipTest001
205  * @tc.desc: Verify function ApplyCanvasClip
206  * @tc.type:FUNC
207  */
208 HWTEST_F(RSImageTest, ApplyCanvasClipTest001, TestSize.Level1)
209 {
210     auto image = std::make_shared<RSImage>();
211     Drawing::Canvas canvas;
212     image->ApplyCanvasClip(canvas);
213     EXPECT_FALSE(image->hasRadius_);
214     image->hasRadius_ = true;
215     image->ApplyCanvasClip(canvas);
216     EXPECT_TRUE(image->hasRadius_);
217 }
218 
219 /**
220  * @tc.name: UploadGpuTest001
221  * @tc.desc: Verify function UploadGpu
222  * @tc.type:FUNC
223  */
224 HWTEST_F(RSImageTest, UploadGpuTest001, TestSize.Level1)
225 {
226     auto image = std::make_shared<RSImage>();
227     Drawing::Canvas canvas = RSPaintFilterCanvas(std::make_shared<Drawing::Canvas>().get());
228     canvas.gpuContext_ = std::make_shared<Drawing::GPUContext>();
229     image->UploadGpu(canvas);
230     image->isYUVImage_ = true;
231     image->UploadGpu(canvas);
232     image->compressData_ = std::make_shared<Drawing::Data>();
233     image->pixelMap_ = CreatePixelMap(200, 300);
234     image->UploadGpu(canvas);
235     EXPECT_EQ(image->compressData_, nullptr);
236 }
237 
238 /**
239  * @tc.name: DrawImageRepeatRectTest001
240  * @tc.desc: Verify function DrawImageRepeatRect
241  * @tc.type:FUNC
242  */
243 HWTEST_F(RSImageTest, DrawImageRepeatRectTest001, TestSize.Level1)
244 {
245     auto image = std::make_shared<RSImage>();
246     Drawing::SamplingOptions samplingOptions;
247     Drawing::Canvas canvas;
248     canvas.impl_ = std::make_shared<Drawing::SkiaCanvas>();
249     image->DrawImageRepeatRect(samplingOptions, canvas);
250     image->pixelMap_ = std::make_shared<Media::PixelMap>();
251     image->pixelMap_->SetAstc(true);
252     image->imageRepeat_ = ImageRepeat::REPEAT_X;
253     image->image_ = std::make_shared<Drawing::Image>();
254     image->DrawImageRepeatRect(samplingOptions, canvas);
255     image->innerRect_ = Drawing::RectI { 0, 0, 10, 10 };
256     image->DrawImageRepeatRect(samplingOptions, canvas);
257     EXPECT_EQ(image->frameRect_.left_, 0);
258 }
259 
260 /**
261  * @tc.name: SetCompressDataTest001
262  * @tc.desc: Verify function SetCompressData
263  * @tc.type:FUNC
264  */
265 HWTEST_F(RSImageTest, SetCompressDataTest001, TestSize.Level1)
266 {
267     auto image = std::make_shared<RSImage>();
268     auto data = std::make_shared<Drawing::Data>();
269     image->SetCompressData(data, 1, 1, 1);
270     EXPECT_NE(image->compressData_, nullptr);
271 }
272 
273 /**
274  * @tc.name: SetCompressDataTest002
275  * @tc.desc: Verify function SetCompressData
276  * @tc.type:FUNC
277  */
278 HWTEST_F(RSImageTest, SetCompressDataTest002, TestSize.Level1)
279 {
280     auto image = std::make_shared<RSImage>();
281     auto data = std::make_shared<Drawing::Data>();
282     image->SetCompressData(data);
283     EXPECT_NE(image->compressData_, nullptr);
284 }
285 
286 /**
287  * @tc.name: SetRadiusTest001
288  * @tc.desc: Verify function SetRadius
289  * @tc.type:FUNC
290  */
291 HWTEST_F(RSImageTest, SetRadiusTest001, TestSize.Level1)
292 {
293     auto image = std::make_shared<RSImage>();
294     std::vector<Drawing::Point> radius = { Drawing::Point { 1.f, 1.f }, Drawing::Point { 1.f, 1.f },
295         Drawing::Point { 1.f, 1.f }, Drawing::Point { 1.f, 1.f } };
296     image->SetRadius(radius);
297     EXPECT_TRUE(image->hasRadius_);
298 }
299 
300 /**
301  * @tc.name: SetScaleTest001
302  * @tc.desc: Verify function SetScale
303  * @tc.type:FUNC
304  */
305 HWTEST_F(RSImageTest, SetScaleTest001, TestSize.Level1)
306 {
307     auto image = std::make_shared<RSImage>();
308     image->SetScale(-1.0);
309     image->SetScale(1.0);
310     EXPECT_EQ(image->scale_, 1.0);
311 }
312 
313 /**
314  * @tc.name: SetNodeIdTest001
315  * @tc.desc: Verify function SetNodeId
316  * @tc.type:FUNC
317  */
318 HWTEST_F(RSImageTest, SetNodeIdTest001, TestSize.Level1)
319 {
320     auto image = std::make_shared<RSImage>();
321     image->SetNodeId(1);
322     EXPECT_EQ(image->nodeId_, 1);
323 }
324 
325 /**
326  * @tc.name: LifeCycle002
327  * @tc.desc:
328  * @tc.type:FUNC
329  */
330 HWTEST_F(RSImageTest, LifeCycle002, TestSize.Level1)
331 {
332     /**
333      * @tc.steps: step1. create RSMask by Gradient
334      */
335     Parcel parcel;
336     ASSERT_TRUE(RSImage::Unmarshalling(parcel) == nullptr);
337     parcel.WriteInt32(1);
338     ASSERT_TRUE(RSImage::Unmarshalling(parcel) == nullptr);
339 }
340 
341 /**
342  * @tc.name: TestRSImage001
343  * @tc.desc: IsEqual test.
344  * @tc.type: FUNC
345  */
346 HWTEST_F(RSImageTest, TestRSImage001, TestSize.Level1)
347 {
348     RSImage image;
349     RSImage other;
350     ASSERT_TRUE(image.IsEqual(other));
351 }
352 
353 /**
354  * @tc.name: TestRSImage002
355  * @tc.desc: CanvasDrawImage test.
356  * @tc.type: FUNC
357  */
358 HWTEST_F(RSImageTest, TestRSImage002, TestSize.Level1)
359 {
360     RSImage image;
361     Drawing::Canvas drawingCanvas;
362     RSPaintFilterCanvas canvas(&drawingCanvas);
363     Drawing::Rect rect;
364     Drawing::Brush brush;
365     bool isBackground = false;
366     canvas.AttachBrush(brush);
367     image.CanvasDrawImage(canvas, rect, Drawing::SamplingOptions(), isBackground);
368     isBackground = true;
369     image.CanvasDrawImage(canvas, rect, Drawing::SamplingOptions(), isBackground);
370     canvas.DetachBrush();
371     EXPECT_NE(&canvas, nullptr);
372 }
373 
374 /**
375  * @tc.name: TestRSImage003
376  * @tc.desc: ApplyImageFit test.
377  * @tc.type: FUNC
378  */
379 HWTEST_F(RSImageTest, TestRSImage003, TestSize.Level1)
380 {
381     RSImage image;
382     Drawing::Canvas drawingCanvas;
383     RSPaintFilterCanvas canvas(&drawingCanvas);
384     Drawing::Rect rect;
385     Drawing::Brush brush;
386     bool isBackground = false;
387     image.SetImageFit(0);
388     canvas.AttachBrush(brush);
389     image.CanvasDrawImage(canvas, rect, Drawing::SamplingOptions(), isBackground);
390     image.SetImageFit(5);
391     image.CanvasDrawImage(canvas, rect, Drawing::SamplingOptions(), isBackground);
392     image.SetImageFit(2);
393     image.CanvasDrawImage(canvas, rect, Drawing::SamplingOptions(), isBackground);
394     image.SetImageFit(3);
395     image.CanvasDrawImage(canvas, rect, Drawing::SamplingOptions(), isBackground);
396     image.SetImageFit(4);
397     image.CanvasDrawImage(canvas, rect, Drawing::SamplingOptions(), isBackground);
398     image.SetImageFit(6);
399     image.CanvasDrawImage(canvas, rect, Drawing::SamplingOptions(), isBackground);
400     image.SetImageFit(1);
401     image.CanvasDrawImage(canvas, rect, Drawing::SamplingOptions(), isBackground);
402     image.SetImageFit(7);
403     image.CanvasDrawImage(canvas, rect, Drawing::SamplingOptions(), isBackground);
404     image.SetImageFit(8);
405     image.CanvasDrawImage(canvas, rect, Drawing::SamplingOptions(), isBackground);
406     canvas.DetachBrush();
407     EXPECT_NE(&canvas, nullptr);
408 }
409 
410 /**
411  * @tc.name: TestRSImage004
412  * @tc.desc: SetImageRepeat test.
413  * @tc.type: FUNC
414  */
415 HWTEST_F(RSImageTest, TestRSImage004, TestSize.Level1)
416 {
417     RSImage image;
418     Drawing::Canvas drawingCanvas;
419     RSPaintFilterCanvas canvas(&drawingCanvas);
420     Drawing::Rect rect = Drawing::Rect(0, 0, 100, 100);
421     RectF dstRect(10, 10, 80, 80);
422     Drawing::Brush brush;
423     image.SetDstRect(dstRect);
424     image.SetImageRepeat(1);
425     canvas.AttachBrush(brush);
426     image.CanvasDrawImage(canvas, rect, Drawing::SamplingOptions());
427     image.SetImageRepeat(2);
428     image.CanvasDrawImage(canvas, rect, Drawing::SamplingOptions());
429     image.SetImageRepeat(3);
430     image.CanvasDrawImage(canvas, rect, Drawing::SamplingOptions());
431     canvas.DetachBrush();
432     EXPECT_NE(&canvas, nullptr);
433 }
434 
435 /**
436  * @tc.name: RSImageBase001
437  * @tc.desc: RSImageBase test.
438  * @tc.type: FUNC
439  */
440 HWTEST_F(RSImageTest, RSImageBase001, TestSize.Level1)
441 {
442     RSImageBase imageBase;
443     RectF rect(0, 0, 100, 100);
444     imageBase.SetSrcRect(rect);
445     imageBase.SetDstRect(rect);
446     Drawing::Canvas drawingCanvas;
447     RSPaintFilterCanvas canvas(&drawingCanvas);
448     Drawing::Brush brush;
449     canvas.AttachBrush(brush);
450     imageBase.DrawImage(canvas, Drawing::SamplingOptions());
451     canvas.DetachBrush();
452 #if defined(ROSEN_OHOS) && (defined(RS_ENABLE_GL) || defined(RS_ENABLE_VK))
453     auto img = std::make_shared<Drawing::Image>();
454     imageBase.SetDmaImage(img);
455 #endif
456 
457 #ifdef ROSEN_OHOS
458     Parcel parcel;
459     EXPECT_FALSE(imageBase.Marshalling(parcel));
460     EXPECT_EQ(imageBase.Unmarshalling(parcel), nullptr);
461 #endif
462 }
463 
464 /**
465  * @tc.name: RSImageCache001
466  * @tc.desc: RSImageBase test.
467  * @tc.type: FUNC
468  */
469 HWTEST_F(RSImageTest, RSImageCache001, TestSize.Level1)
470 {
471     auto rsImage = std::make_shared<RSImage>();
472     std::shared_ptr<Media::PixelMap> pixelMap;
473     int width = 200;
474     int height = 300;
475     pixelMap = CreatePixelMap(width, height);
476     rsImage->SetPixelMap(pixelMap);
477 
478     MessageParcel parcel;
479     EXPECT_EQ(RSMarshallingHelper::Marshalling(parcel, rsImage), true);
480     std::shared_ptr<RSImage> newImage;
481     EXPECT_EQ(RSMarshallingHelper::Unmarshalling(parcel, newImage), true);
482 
483     Drawing::Canvas drawingCanvas;
484     RSPaintFilterCanvas canvas(&drawingCanvas);
485     Drawing::Brush brush;
486     Drawing::Rect rect = Drawing::Rect(0, 0, 100, 100);
487     canvas.AttachBrush(brush);
488     newImage->CanvasDrawImage(canvas, rect, Drawing::SamplingOptions());
489     newImage->CanvasDrawImage(canvas, rect, Drawing::SamplingOptions());
490     canvas.DetachBrush();
491 
492     MessageParcel parcel2;
493     EXPECT_EQ(RSMarshallingHelper::Marshalling(parcel2, rsImage), true);
494     std::shared_ptr<RSImage> newImage2;
495     EXPECT_EQ(RSMarshallingHelper::Unmarshalling(parcel2, newImage2), true);
496 
497     RSImageCache::Instance().CachePixelMap(1, nullptr);
498     RSImageCache::Instance().CachePixelMap(0, pixelMap);
499     RSImageCache::Instance().CacheRenderDrawingImageByPixelMapId(1, nullptr);
500     RSImageCache::Instance().CacheRenderDrawingImageByPixelMapId(0, nullptr);
501 
502     auto img = std::make_shared<Drawing::Image>();
503     RSImageCache::Instance().CacheDrawingImage(0, img);
504 
505     EXPECT_EQ(RSImageCache::Instance().GetDrawingImageCache(0), nullptr);
506 
507     RSImageCache::Instance().IncreaseDrawingImageCacheRefCount(0);
508 }
509 
510 /**
511  * @tc.name: SetInnerRectTest
512  * @tc.desc: Verify function SetInnerRect
513  * @tc.type:FUNC
514  * @tc.require: issuesI9MO9U
515  */
516 HWTEST_F(RSImageTest, SetInnerRectTest, TestSize.Level1)
517 {
518     auto rsImage = std::make_shared<RSImage>();
519     auto innerRect = std::make_optional<Drawing::RectI>();
520     rsImage->SetInnerRect(innerRect);
521     EXPECT_NE(rsImage, nullptr);
522 }
523 
524 /**
525  * @tc.name: SetPaintTest
526  * @tc.desc: Verify function SetPaint
527  * @tc.type:FUNC
528  * @tc.require:
529  */
530 HWTEST_F(RSImageTest, SetPaintTest, TestSize.Level1)
531 {
532     auto rsImage = std::make_shared<RSImage>();
533     ASSERT_NE(rsImage, nullptr);
534     Drawing::Paint paint;
535     rsImage->SetPaint(paint);
536     EXPECT_EQ(rsImage->paint_, paint);
537 }
538 
539 /**
540  * @tc.name: dumpTest
541  * @tc.desc: Verify function dump
542  * @tc.type:FUNC
543  * @tc.require: issuesI9MO9U
544  */
545 HWTEST_F(RSImageTest, dumpTest, TestSize.Level1)
546 {
547     auto rsImage = std::make_shared<RSImage>();
548     auto innerRect = std::make_optional<Drawing::RectI>();
549     ASSERT_NE(rsImage, nullptr);
550     std::string desc = "dump ";
551     rsImage->dump(desc, 0);
552     EXPECT_NE(desc, "dump ");
553 }
554 } // namespace OHOS::Rosen
555