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 <cstddef>
17
18 #include "gtest/gtest.h"
19 #include "skia_adapter/skia_canvas.h"
20 #include "skia_adapter/skia_gpu_context.h"
21 #include "skia_adapter/skia_image.h"
22 #include "skia_adapter/skia_surface.h"
23
24 #include "draw/surface.h"
25 #include "image/image.h"
26
27 using namespace testing;
28 using namespace testing::ext;
29
30 namespace OHOS {
31 namespace Rosen {
32 namespace Drawing {
33 class SkiaImageTest : public testing::Test {
34 public:
35 static void SetUpTestCase();
36 static void TearDownTestCase();
37 void SetUp() override;
38 void TearDown() override;
39 };
40
SetUpTestCase()41 void SkiaImageTest::SetUpTestCase() {}
TearDownTestCase()42 void SkiaImageTest::TearDownTestCase() {}
SetUp()43 void SkiaImageTest::SetUp() {}
TearDown()44 void SkiaImageTest::TearDown() {}
45
46 /**
47 * @tc.name: BuildFromBitmap001
48 * @tc.desc:
49 * @tc.type: FUNC
50 * @tc.author:
51 */
52 HWTEST_F(SkiaImageTest, BuildFromBitmap001, TestSize.Level1)
53 {
54 Bitmap bitmap;
55 std::shared_ptr<SkiaImage> skiaImage = std::make_shared<SkiaImage>();
56 auto image = skiaImage->BuildFromBitmap(bitmap);
57 EXPECT_EQ(image, false);
58 }
59
60 /**
61 * @tc.name: MakeRasterData001
62 * @tc.desc: Test MakeRasterData
63 * @tc.type: FUNC
64 * @tc.require: I91EH1
65 */
66 HWTEST_F(SkiaImageTest, MakeRasterData001, TestSize.Level1)
67 {
68 std::shared_ptr<SkiaImage> skiaImage = std::make_shared<SkiaImage>();
69 ImageInfo imageInfo;
70 auto image = skiaImage->MakeRasterData(imageInfo, nullptr, 0);
71 EXPECT_TRUE(image == nullptr);
72 std::shared_ptr<Data> data = std::make_shared<Data>();
73 data->BuildUninitialized(100);
74 auto image2 = skiaImage->MakeRasterData(imageInfo, data, 100);
75 EXPECT_TRUE(image2 == nullptr);
76 }
77
78 #ifdef RS_ENABLE_GPU
79 /**
80 * @tc.name: MakeFromEncoded001
81 * @tc.desc: Test MakeFromEncoded
82 * @tc.type: FUNC
83 * @tc.require: I91EH1
84 */
85 HWTEST_F(SkiaImageTest, MakeFromEncoded001, TestSize.Level1)
86 {
87 std::shared_ptr<SkiaImage> skiaImage = std::make_shared<SkiaImage>();
88 auto ret = skiaImage->MakeFromEncoded(nullptr);
89 EXPECT_TRUE(!ret);
90 }
91
92 /**
93 * @tc.name: BuildSubset001
94 * @tc.desc: Test BuildSubset
95 * @tc.type: FUNC
96 * @tc.require: I91EH1
97 */
98 HWTEST_F(SkiaImageTest, BuildSubset001, TestSize.Level1)
99 {
100 auto surface = std::make_unique<SkiaSurface>();
101 surface->FlushAndSubmit(true);
102 Bitmap bitmap;
103 BitmapFormat bitmapFormat { COLORTYPE_RGBA_8888, ALPHATYPE_OPAQUE };
104 bitmap.Build(100, 100, bitmapFormat);
105 ASSERT_TRUE(surface->Bind(bitmap));
106
107 auto image = surface->GetImageSnapshot();
108 GPUContext context;
109 #ifdef NEW_SKIA
110 GrMockOptions options;
111 context.GetImpl<SkiaGPUContext>()->SetGrContext(GrDirectContext::MakeMock(&options));
112 #endif
113 auto skiaImage = image->GetImpl<SkiaImage>();
114 if (skiaImage) {
115 RectI rect;
116 GPUContext context;
117 skiaImage->BuildSubset(nullptr, rect, context);
118 }
119 }
120
121 /**
122 * @tc.name: BuildSubset002
123 * @tc.desc: Test BuildSubset002
124 * @tc.type: FUNC
125 * @tc.require: I91EH1
126 */
127 HWTEST_F(SkiaImageTest, BuildSubset002, TestSize.Level1)
128 {
129 std::shared_ptr<SkiaImage> skiaImage = std::make_shared<SkiaImage>();
130 std::unique_ptr<Bitmap> bitmap = std::make_unique<Bitmap>();
131 ASSERT_TRUE(bitmap != nullptr);
132 EXPECT_TRUE(bitmap->Build(151, 150, { ColorType::COLORTYPE_ALPHA_8, AlphaType::ALPHATYPE_OPAQUE }));
133 std::shared_ptr<Image> image = bitmap->MakeImage();
134 ASSERT_TRUE(image != nullptr);
135 RectI rect;
136 GPUContext context;
137 bool result = skiaImage->BuildSubset(image, rect, context);
138 ASSERT_FALSE(result);
139 }
140
141 /**
142 * @tc.name: BuildFromTexture001
143 * @tc.desc: Test BuildFromTexture
144 * @tc.type: FUNC
145 * @tc.require: I91EH1
146 */
147 HWTEST_F(SkiaImageTest, BuildFromTexture001, TestSize.Level1)
148 {
149 std::shared_ptr<SkiaImage> skiaImage = std::make_shared<SkiaImage>();
150 GPUContext context;
151 TextureInfo textureInfo;
152 textureInfo.SetWidth(10);
153 BitmapFormat bitmapFormat { COLORTYPE_RGBA_8888, ALPHATYPE_OPAQUE };
154 bool ret1 = skiaImage->BuildFromTexture(context, textureInfo, TextureOrigin::TOP_LEFT,
155 bitmapFormat, nullptr, nullptr, nullptr);
156 ASSERT_FALSE(ret1);
157 auto colorSpace = std::make_shared<ColorSpace>(ColorSpace::ColorSpaceType::NO_TYPE);
158 bool ret2 = skiaImage->BuildFromTexture(
159 context, textureInfo, TextureOrigin::TOP_LEFT, bitmapFormat, colorSpace, nullptr, nullptr);
160 ASSERT_FALSE(ret2);
161 }
162
163 /**
164 * @tc.name: BuildFromTexture002
165 * @tc.desc: Test BuildFromTexture
166 * @tc.type: FUNC
167 * @tc.require: I91EH1
168 */
169 HWTEST_F(SkiaImageTest, BuildFromTexture002, TestSize.Level1)
170 {
171 std::shared_ptr<SkiaImage> skiaImage = std::make_shared<SkiaImage>();
172 GPUContext context;
173 TextureInfo textureInfo;
174 textureInfo.SetWidth(10);
175 BitmapFormat bitmapFormat { COLORTYPE_RGBA_8888, ALPHATYPE_OPAQUE };
176 bool buildFromTexture = skiaImage->BuildFromTexture(
177 context, textureInfo, TextureOrigin::TOP_LEFT, bitmapFormat, nullptr, nullptr, nullptr);
178 ASSERT_FALSE(buildFromTexture);
179 }
180
181 /**
182 * @tc.name: BuildFromSurface001
183 * @tc.desc: Test BuildFromSurface
184 * @tc.type: FUNC
185 * @tc.require: I91EH1
186 */
187 HWTEST_F(SkiaImageTest, BuildFromSurface001, TestSize.Level1)
188 {
189 std::shared_ptr<SkiaImage> skiaImage = std::make_shared<SkiaImage>();
190 auto skiaCanvas = std::make_shared<SkiaCanvas>();
191 auto gpuContext = skiaCanvas->GetGPUContext();
192 auto surface = Surface::MakeRasterN32Premul(800, 800);
193 BitmapFormat bitmapFormat { COLORTYPE_RGBA_8888, ALPHATYPE_OPAQUE };
194 auto colorSpace = std::make_shared<ColorSpace>(ColorSpace::ColorSpaceType::NO_TYPE);
195 auto ret = skiaImage->BuildFromSurface(*gpuContext, *surface, TextureOrigin::TOP_LEFT, bitmapFormat, colorSpace);
196 ASSERT_TRUE(!ret);
197 ASSERT_TRUE(skiaImage->GetColorSpace() == nullptr);
198 }
199
200 /**
201 * @tc.name: BuildFromSurface002
202 * @tc.desc: Test BuildFromSurface
203 * @tc.type: FUNC
204 * @tc.require: I91EH1
205 */
206 HWTEST_F(SkiaImageTest, BuildFromSurface002, TestSize.Level1)
207 {
208 auto skiaCanvas = std::make_shared<SkiaCanvas>();
209 auto gpuContext = skiaCanvas->GetGPUContext();
210 BitmapFormat bitmapFormat { COLORTYPE_RGBA_8888, ALPHATYPE_OPAQUE };
211 auto colorSpace = std::make_shared<ColorSpace>(ColorSpace::ColorSpaceType::NO_TYPE);
212 std::shared_ptr<SkiaImage> skiaImage = std::make_shared<SkiaImage>();
213 Surface surFace;
214 auto ret = skiaImage->BuildFromSurface(*gpuContext, surFace, TextureOrigin::TOP_LEFT, bitmapFormat, colorSpace);
215 ASSERT_FALSE(ret);
216 }
217
218 /**
219 * @tc.name: IsTextureBacked002
220 * @tc.desc: Test GetBackendTexture
221 * @tc.type: FUNC
222 * @tc.require: I91EH1
223 */
224 HWTEST_F(SkiaImageTest, IsTextureBacked002, TestSize.Level1)
225 {
226 auto surface = std::make_unique<SkiaSurface>();
227 surface->FlushAndSubmit(true);
228 Bitmap bitmap;
229 BitmapFormat bitmapFormat { COLORTYPE_RGBA_8888, ALPHATYPE_OPAQUE };
230 bitmap.Build(100, 100, bitmapFormat);
231 ASSERT_TRUE(surface->Bind(bitmap));
232
233 auto image = surface->GetImageSnapshot();
234 if (image) {
235 auto skiaImage = image->GetImpl<SkiaImage>();
236 if (skiaImage) {
237 ASSERT_TRUE(skiaImage->IsValid(nullptr));
238 ASSERT_TRUE(!skiaImage->IsTextureBacked());
239 ASSERT_TRUE(!skiaImage->IsLazyGenerated());
240 ASSERT_TRUE(skiaImage->CanPeekPixels());
241 ASSERT_TRUE(skiaImage->IsOpaque());
242 }
243 }
244 }
245
246 /**
247 * @tc.name: IsValid001
248 * @tc.desc: Test IsValid
249 * @tc.type: FUNC
250 * @tc.require: I91EH1
251 */
252 HWTEST_F(SkiaImageTest, IsValid001, TestSize.Level1)
253 {
254 Bitmap bitmap;
255 std::shared_ptr<SkiaImage> skiaImage = std::make_shared<SkiaImage>();
256 ASSERT_TRUE(!skiaImage->IsValid(nullptr));
257 auto ret = skiaImage->BuildFromBitmap(bitmap);
258 if (ret) {
259 ASSERT_TRUE(!skiaImage->IsValid(nullptr));
260 GPUContext context;
261 ASSERT_TRUE(skiaImage->IsValid(&context));
262 }
263 }
264
265 /**
266 * @tc.name: MakeFromYUVAPixmaps
267 * @tc.desc: Test MakeFromYUVAPixmaps
268 * @tc.type: FUNC
269 * @tc.require: I91EH1
270 */
271 HWTEST_F(SkiaImageTest, MakeFromYUVAPixmaps, TestSize.Level1)
272 {
273 Bitmap bitmap;
274 GPUContext gpuContext;
275 YUVInfo info(100, 100, YUVInfo::PlaneConfig::Y_UV, YUVInfo::SubSampling::K420,
276 YUVInfo::YUVColorSpace::JPEG_FULL_YUVCOLORSPACE);
277 std::shared_ptr<SkiaImage> skiaImage = std::make_shared<SkiaImage>();
278 std::shared_ptr<Image> image = skiaImage->MakeFromYUVAPixmaps(gpuContext, info, nullptr);
279 ASSERT_TRUE(image == nullptr);
280 }
281
282
283 /**
284 * @tc.name: BuildFromCompressed
285 * @tc.desc: Test BuildFromCompressed
286 * @tc.type: FUNC
287 * @tc.require: I91EH1
288 */
289 HWTEST_F(SkiaImageTest, BuildFromCompressed, TestSize.Level1)
290 {
291 const int height = 100;
292 const int width = 100;
293 std::shared_ptr<SkiaImage> skiaImage = std::make_shared<SkiaImage>();
294 GPUContext context;
295 bool result = skiaImage->BuildFromCompressed(context, nullptr, width, height, CompressedType::ETC2_RGB8_UNORM);
296 ASSERT_FALSE(result);
297 }
298
299 /**
300 * @tc.name: SetGrBackendTexture
301 * @tc.desc: Test SetGrBackendTexture
302 * @tc.type: FUNC
303 * @tc.require: I91EH1
304 */
305 HWTEST_F(SkiaImageTest, SetGrBackendTexture, TestSize.Level1)
306 {
307 std::shared_ptr<SkiaImage> skiaImage = std::make_shared<SkiaImage>();
308 ASSERT_TRUE(skiaImage != nullptr);
309 GrBackendTexture skBackendTexture;
310 skiaImage->SetGrBackendTexture(skBackendTexture);
311 }
312 #endif
313
314 /**
315 * @tc.name: IsLazyGenerated001
316 * @tc.desc: Test IsLazyGenerated
317 * @tc.type: FUNC
318 * @tc.require: I91EH1
319 */
320 HWTEST_F(SkiaImageTest, IsLazyGenerated001, TestSize.Level1)
321 {
322 auto surface = std::make_unique<SkiaSurface>();
323 surface->FlushAndSubmit(true);
324 Bitmap bitmap;
325 BitmapFormat bitmapFormat { COLORTYPE_RGBA_8888, ALPHATYPE_OPAQUE };
326 bitmap.Build(100, 100, bitmapFormat);
327 ASSERT_TRUE(surface->Bind(bitmap));
328
329 auto image = surface->GetImageSnapshot();
330 auto skiaImage = image->GetImpl<SkiaImage>();
331 ASSERT_TRUE(skiaImage->GetImage() != nullptr);
332 skiaImage->GetColorType();
333 skiaImage->GetAlphaType();
334 ASSERT_TRUE(skiaImage->EncodeToData(EncodedImageFormat::JPEG, 1) != nullptr);
335 ASSERT_TRUE(skiaImage->GetColorSpace() == nullptr);
336 ASSERT_TRUE(skiaImage->MakeRasterImage() != nullptr);
337 ASSERT_TRUE(!skiaImage->IsTextureBacked());
338 ASSERT_TRUE(!skiaImage->IsLazyGenerated());
339 ASSERT_TRUE(skiaImage->CanPeekPixels());
340 ASSERT_TRUE(skiaImage->IsOpaque());
341 Bitmap bitmap2;
342 ASSERT_TRUE(skiaImage->GetROPixels(bitmap2));
343 Pixmap pixmap;
344 skiaImage->ReadPixels(pixmap, 100, 100);
345 Bitmap bitmap3;
346 CubicResampler cubicResampler;
347 SamplingOptions options1 { cubicResampler };
348 ASSERT_TRUE(!skiaImage->ScalePixels(bitmap3, options1, false));
349 }
350
351 /**
352 * @tc.name: IsLazyGenerated002
353 * @tc.desc: Test IsLazyGenerated
354 * @tc.type: FUNC
355 * @tc.require: I91EH1
356 */
357 HWTEST_F(SkiaImageTest, IsLazyGenerated002, TestSize.Level1)
358 {
359 std::shared_ptr<SkiaImage> skiaImage = std::make_shared<SkiaImage>();
360 ASSERT_TRUE(!skiaImage->IsLazyGenerated());
361 }
362
363 /**
364 * @tc.name: AsLegacyBitmap001
365 * @tc.desc: Test AsLegacyBitmap
366 * @tc.type: FUNC
367 * @tc.require: I91EH1
368 */
369 HWTEST_F(SkiaImageTest, AsLegacyBitmap001, TestSize.Level1)
370 {
371 std::shared_ptr<SkiaImage> skiaImage = std::make_shared<SkiaImage>();
372 Bitmap bitmap;
373 ASSERT_TRUE(!skiaImage->AsLegacyBitmap(bitmap));
374 }
375
376 /**
377 * @tc.name: IsOpaque001
378 * @tc.desc: Test IsOpaque
379 * @tc.type: FUNC
380 * @tc.require: I91EH1
381 */
382 HWTEST_F(SkiaImageTest, IsOpaque001, TestSize.Level1)
383 {
384 std::shared_ptr<SkiaImage> skiaImage = std::make_shared<SkiaImage>();
385 ASSERT_TRUE(!skiaImage->IsOpaque());
386 }
387
388 /**
389 * @tc.name: GetAlphaType001
390 * @tc.desc: Test GetAlphaType
391 * @tc.type: FUNC
392 * @tc.require: I91EH1
393 */
394 HWTEST_F(SkiaImageTest, GetAlphaType001, TestSize.Level1)
395 {
396 std::shared_ptr<SkiaImage> skiaImage = std::make_shared<SkiaImage>();
397 ASSERT_TRUE(skiaImage->GetAlphaType() == AlphaType::ALPHATYPE_UNKNOWN);
398 }
399
400 /**
401 * @tc.name: GetColorType001
402 * @tc.desc: Test GetColorType
403 * @tc.type: FUNC
404 * @tc.require: I91EH1
405 */
406 HWTEST_F(SkiaImageTest, GetColorType001, TestSize.Level1)
407 {
408 std::shared_ptr<SkiaImage> skiaImage = std::make_shared<SkiaImage>();
409 ASSERT_TRUE(skiaImage->GetColorType() == ColorType::COLORTYPE_UNKNOWN);
410 }
411
412 /**
413 * @tc.name: GetColorSpace001
414 * @tc.desc: Test GetColorSpace
415 * @tc.type: FUNC
416 * @tc.require: I91EH1
417 */
418 HWTEST_F(SkiaImageTest, GetColorSpace001, TestSize.Level1)
419 {
420 std::shared_ptr<SkiaImage> skiaImage = std::make_shared<SkiaImage>();
421 ASSERT_TRUE(skiaImage->GetColorSpace() == nullptr);
422 }
423
424 /**
425 * @tc.name: GetImageInfo001
426 * @tc.desc: Test GetImageInfo
427 * @tc.type: FUNC
428 * @tc.require: I91EH1
429 */
430 HWTEST_F(SkiaImageTest, GetImageInfo001, TestSize.Level1)
431 {
432 std::shared_ptr<SkiaImage> skiaImage = std::make_shared<SkiaImage>();
433 ASSERT_TRUE(skiaImage->GetImageInfo().GetWidth() == 0);
434 }
435
436 /**
437 * @tc.name: IsTextureBacked001
438 * @tc.desc: Test IsTextureBacked
439 * @tc.type: FUNC
440 * @tc.require: I91EH1
441 */
442 HWTEST_F(SkiaImageTest, IsTextureBacked001, TestSize.Level1)
443 {
444 std::shared_ptr<SkiaImage> skiaImage = std::make_shared<SkiaImage>();
445 ASSERT_TRUE(!skiaImage->IsTextureBacked());
446 }
447
448 /**
449 * @tc.name: ReadPixels001
450 * @tc.desc: Test ReadPixels
451 * @tc.type: FUNC
452 * @tc.require: I91EH1
453 */
454 HWTEST_F(SkiaImageTest, ReadPixels001, TestSize.Level1)
455 {
456 std::shared_ptr<SkiaImage> skiaImage = std::make_shared<SkiaImage>();
457 Pixmap pixmap;
458 ASSERT_FALSE(skiaImage->ReadPixels(pixmap, 0, 0));
459 ImageInfo dstInfo = ImageInfo::MakeN32Premul(100, 100); // 100: width, height
460 ASSERT_FALSE(skiaImage->ReadPixels(dstInfo, nullptr, 100, 100, 100)); // 100: dstRowBytes, srcX, srcY
461 }
462
463 /**
464 * @tc.name: ScalePixels001
465 * @tc.desc: Test ScalePixels
466 * @tc.type: FUNC
467 * @tc.require: I91EH1
468 */
469 HWTEST_F(SkiaImageTest, ScalePixels001, TestSize.Level1)
470 {
471 std::shared_ptr<SkiaImage> skiaImage = std::make_shared<SkiaImage>();
472 Bitmap bitmap;
473 CubicResampler cubicResampler;
474 SamplingOptions options1 { cubicResampler };
475 ASSERT_TRUE(!skiaImage->ScalePixels(bitmap, options1, false));
476 SamplingOptions options2;
477 ASSERT_TRUE(!skiaImage->ScalePixels(bitmap, options2, true));
478 }
479
480 /**
481 * @tc.name: EncodeToData001
482 * @tc.desc: Test EncodeToData
483 * @tc.type: FUNC
484 * @tc.require: I91EH1
485 */
486 HWTEST_F(SkiaImageTest, EncodeToData001, TestSize.Level1)
487 {
488 std::shared_ptr<SkiaImage> skiaImage = std::make_shared<SkiaImage>();
489 ASSERT_TRUE(skiaImage->EncodeToData(EncodedImageFormat::JPEG, 1) == nullptr);
490 }
491
492 /**
493 * @tc.name: MakeRasterImage001
494 * @tc.desc: Test MakeRasterImage
495 * @tc.type: FUNC
496 * @tc.require: I91EH1
497 */
498 HWTEST_F(SkiaImageTest, MakeRasterImage001, TestSize.Level1)
499 {
500 std::shared_ptr<SkiaImage> skiaImage = std::make_shared<SkiaImage>();
501 ASSERT_TRUE(skiaImage->MakeRasterImage() == nullptr);
502 }
503
504 /**
505 * @tc.name: GetROPixels001
506 * @tc.desc: Test GetROPixels
507 * @tc.type: FUNC
508 * @tc.require: I91EH1
509 */
510 HWTEST_F(SkiaImageTest, GetROPixels001, TestSize.Level1)
511 {
512 std::shared_ptr<SkiaImage> skiaImage = std::make_shared<SkiaImage>();
513 Bitmap bitmap;
514 ASSERT_TRUE(!skiaImage->GetROPixels(bitmap));
515 }
516
517 /**
518 * @tc.name: CanPeekPixels001
519 * @tc.desc: Test CanPeekPixels
520 * @tc.type: FUNC
521 * @tc.require: I91EH1
522 */
523 HWTEST_F(SkiaImageTest, CanPeekPixels001, TestSize.Level1)
524 {
525 std::shared_ptr<SkiaImage> skiaImage = std::make_shared<SkiaImage>();
526 ASSERT_TRUE(!skiaImage->CanPeekPixels());
527 }
528
529 /**
530 * @tc.name: GetImage001
531 * @tc.desc: Test GetImage
532 * @tc.type: FUNC
533 * @tc.require: I91EH1
534 */
535 HWTEST_F(SkiaImageTest, GetImage001, TestSize.Level1)
536 {
537 sk_sp<SkImage> img;
538 SkiaImage skiaImage;
539 skiaImage.SetSkImage(img);
540 ASSERT_TRUE(skiaImage.GetImage() == img);
541 }
542
543 /**
544 * @tc.name: MakeFromRaster
545 * @tc.desc: Test MakeFromRaster
546 * @tc.type: FUNC
547 * @tc.require: I91EH1
548 */
549 HWTEST_F(SkiaImageTest, MakeFromRaster, TestSize.Level1)
550 {
551 Pixmap pixmap;
552 std::shared_ptr<SkiaImage> skiaImage = std::make_shared<SkiaImage>();
553 std::shared_ptr<Image> image = skiaImage->MakeFromRaster(pixmap, nullptr, nullptr);
554 ASSERT_TRUE(image == nullptr);
555 }
556
557 } // namespace Drawing
558 } // namespace Rosen
559 } // namespace OHOS