1 /*
2  * Copyright (c) 2024 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 "sk_image_chain_unittest.h"
17 #include "sk_image_chain.h"
18 #include "sk_image_filter_factory.h"
19 
20 using namespace testing;
21 using namespace testing::ext;
22 
23 namespace OHOS {
24 namespace Rosen {
25 
26 /**
27  * @tc.name: Render_CPU_Normal_Process
28  * @tc.desc: render normaly.
29  * @tc.type: FUNC
30  * @tc.require:
31  * @tc.author:
32  */
33 HWTEST_F(SKImageChainUnittest, Render_CPU_Normal_Process, TestSize.Level1)
34 {
35     Media::InitializationOptions opts;
36     opts.size.width = 2048;
37     opts.size.height = 2048;
38     opts.editable = true;
39     auto uniPixelMap = Media::PixelMap::Create(opts);
40     std::shared_ptr<Media::PixelMap> srcPixelMap(std::move(uniPixelMap));
41 
42     auto filterBlur = Rosen::SKImageFilterFactory::Blur(0.5);
43     std::vector<sk_sp<SkImageFilter>> imageFilter;
44     imageFilter.emplace_back(filterBlur);
45 
46     std::shared_ptr<Media::PixelMap> dstPixelMap = nullptr;
47     Rosen::SKImageChain skImage(srcPixelMap);
48     DrawError ret = skImage.Render(imageFilter, true, dstPixelMap);
49     ASSERT_EQ(ret, DrawError::ERR_OK);
50 }
51 
52 /**
53  * @tc.name: Render_CPU_Filter_10_Times
54  * @tc.desc: render filter 10 times.
55  * @tc.type: FUNC
56  * @tc.require:
57  * @tc.author:
58  */
59 HWTEST_F(SKImageChainUnittest, Render_CPU_Filter_10_Times, TestSize.Level1)
60 {
61     Media::InitializationOptions opts;
62     opts.size.width = 2048;
63     opts.size.height = 2048;
64     opts.editable = true;
65     auto uniPixelMap = Media::PixelMap::Create(opts);
66     std::shared_ptr<Media::PixelMap> srcPixelMap(std::move(uniPixelMap));
67 
68     std::vector<sk_sp<SkImageFilter>> imageFilter;
69     for (int i = 0; i < 10; ++i) {
70         auto filterBlur = Rosen::SKImageFilterFactory::Blur(i);
71         imageFilter.emplace_back(filterBlur);
72     }
73 
74     std::shared_ptr<Media::PixelMap> dstPixelMap = nullptr;
75     Rosen::SKImageChain skImage(srcPixelMap);
76     DrawError ret = skImage.Render(imageFilter, true, dstPixelMap);
77     ASSERT_EQ(ret, DrawError::ERR_OK);
78 }
79 
80 /**
81  * @tc.name: Render_Options_Size_Is_Negative
82  * @tc.desc: render options Size is negative.
83  * @tc.type: FUNC
84  * @tc.require:
85  * @tc.author:
86  */
87 HWTEST_F(SKImageChainUnittest, Render_Options_Size_Is_Negative, TestSize.Level1)
88 {
89     Media::InitializationOptions opts;
90     opts.size.width = -1;
91     opts.size.height = -1;
92     opts.editable = true;
93     auto uniPixelMap = Media::PixelMap::Create(opts);
94     ASSERT_EQ(uniPixelMap, nullptr);
95 
96     std::shared_ptr<Media::PixelMap> srcPixelMap(std::move(uniPixelMap));
97     ASSERT_EQ(srcPixelMap, nullptr);
98 
99     auto filterBlur = Rosen::SKImageFilterFactory::Blur(0.5);
100     std::vector<sk_sp<SkImageFilter>> imageFilter;
101     imageFilter.emplace_back(filterBlur);
102 
103     std::shared_ptr<Media::PixelMap> dstPixelMap = nullptr;
104     Rosen::SKImageChain skImage(srcPixelMap);
105     DrawError ret = skImage.Render(imageFilter, true, dstPixelMap);
106     ASSERT_NE(ret, DrawError::ERR_OK);
107 }
108 
109 
110 /**
111  * @tc.name: Render_Blur_Radius_Is_Negative
112  * @tc.desc: render blur radius is negative.
113  * @tc.type: FUNC
114  * @tc.require:
115  * @tc.author:
116  */
117 HWTEST_F(SKImageChainUnittest, Render_Blur_Radius_Is_Negative, TestSize.Level1)
118 {
119     Media::InitializationOptions opts;
120     opts.size.width = 2048;
121     opts.size.height = 2048;
122     opts.editable = true;
123     auto uniPixelMap = Media::PixelMap::Create(opts);
124     std::shared_ptr<Media::PixelMap> srcPixelMap(std::move(uniPixelMap));
125 
126     auto filterBlur = Rosen::SKImageFilterFactory::Blur(-10);
127     ASSERT_EQ(filterBlur, nullptr);
128     std::vector<sk_sp<SkImageFilter>> imageFilter;
129     imageFilter.emplace_back(filterBlur);
130 
131     std::shared_ptr<Media::PixelMap> dstPixelMap = nullptr;
132     Rosen::SKImageChain skImage(srcPixelMap);
133     DrawError ret = skImage.Render(imageFilter, true, dstPixelMap);
134     ASSERT_EQ(ret, DrawError::ERR_OK);
135 }
136 
137 /**
138  * @tc.name: Render_SKImageChain_srcPixelMap_Is_Null
139  * @tc.desc: render pixelMap is null.
140  * @tc.type: FUNC
141  * @tc.require:
142  * @tc.author:
143  */
144 HWTEST_F(SKImageChainUnittest, Render_SKImageChain_srcPixelMap_Is_Null, TestSize.Level1)
145 {
146     auto filterBlur = Rosen::SKImageFilterFactory::Blur(10);
147     std::vector<sk_sp<SkImageFilter>> imageFilter;
148     imageFilter.emplace_back(filterBlur);
149 
150     std::shared_ptr<Media::PixelMap> dstPixelMap = nullptr;
151     std::shared_ptr<Media::PixelMap> srcPixelMap = nullptr;
152     Rosen::SKImageChain skImage(srcPixelMap);
153     DrawError ret = skImage.Render(imageFilter, true, dstPixelMap);
154     ASSERT_NE(ret, DrawError::ERR_OK);
155 }
156 
157 /**
158  * @tc.name: DrawTest001
159  * @tc.desc: draw nothing
160  * @tc.type: FUNC
161  * @tc.require:
162  * @tc.author:
163  */
164 HWTEST_F(SKImageChainUnittest, DrawTest001, TestSize.Level1)
165 {
166     GTEST_LOG_(INFO) << "SKImageChainUnittest DrawTest001 start";
167 
168     // create from PixelMap
169     auto skImageChain = std::make_shared<SKImageChain>(nullptr, nullptr);
170     ASSERT_NE(skImageChain, nullptr);
171 
172     skImageChain->Draw();
173     skImageChain->ForceCPU(false);
174     skImageChain->Draw();
175 }
176 
177 /**
178  * @tc.name: DrawTest002
179  * @tc.desc: create a SKImageChain with PixelMap and draw
180  * @tc.type: FUNC
181  * @tc.require:
182  * @tc.author:
183  */
184 HWTEST_F(SKImageChainUnittest, DrawTest002, TestSize.Level1)
185 {
186     GTEST_LOG_(INFO) << "SKImageChainUnittest DrawTest002 start";
187 
188     // create from PixelMap
189     Media::InitializationOptions opts;
190     opts.size.width = 1;
191     opts.size.height = 1;
192     opts.editable = true;
193     auto uniPixelMap = Media::PixelMap::Create(opts);
194     ASSERT_NE(uniPixelMap, nullptr);
195 
196     std::shared_ptr<Media::PixelMap> srcPixelMap(std::move(uniPixelMap));
197     auto skImageChain = std::make_shared<SKImageChain>(srcPixelMap);
198     ASSERT_NE(skImageChain, nullptr);
199 
200     skImageChain->Draw();
201     skImageChain->ForceCPU(false);
202     skImageChain->Draw();
203     skImageChain->ForceCPU(true);
204 }
205 
206 /**
207  * @tc.name: DrawTest003
208  * @tc.desc: create a SKImageChain with non-nullptr canvas and draw
209  * @tc.type: FUNC
210  * @tc.require:
211  * @tc.author:
212  */
213 HWTEST_F(SKImageChainUnittest, DrawTest003, TestSize.Level1)
214 {
215     GTEST_LOG_(INFO) << "SKImageChainUnittest DrawTest003 start";
216 
217     // create from PixelMap
218     Media::InitializationOptions opts;
219     opts.size.width = 1;
220     opts.size.height = 1;
221     opts.editable = true;
222     auto uniPixelMap = Media::PixelMap::Create(opts);
223     ASSERT_NE(uniPixelMap, nullptr);
224 
225     std::shared_ptr<Media::PixelMap> srcPixelMap(std::move(uniPixelMap));
226     SkImageInfo imageInfo = SkImageInfo::Make(srcPixelMap->GetWidth(), srcPixelMap->GetHeight(),
227         SkColorType::kRGBA_8888_SkColorType,
228         static_cast<SkAlphaType>(srcPixelMap->GetAlphaType()));
229     std::shared_ptr<SkPixmap> dstPixmap = std::make_shared<SkPixmap>(imageInfo, srcPixelMap->GetPixels(),
230         srcPixelMap->GetRowStride());
231     sk_sp<SkSurface> cpuSurface = SkSurface::MakeRasterDirect(imageInfo, const_cast<void*>(dstPixmap->addr()),
232         srcPixelMap->GetRowStride());
233     ASSERT_NE(cpuSurface, nullptr);
234 
235     auto canvas = cpuSurface->getCanvas();
236     ASSERT_NE(canvas, nullptr);
237     auto skImageChain = std::make_shared<SKImageChain>(canvas, nullptr);
238     ASSERT_NE(skImageChain, nullptr);
239 
240     skImageChain->Draw();
241     skImageChain->ForceCPU(false);
242     skImageChain->Draw();
243     skImageChain->ForceCPU(true);
244 }
245 
246 HWTEST_F(SKImageChainUnittest, CreateEffect_Blur_GetPixelMap_CPU, TestSize.Level1)
247 {
248     GTEST_LOG_(INFO) << "SKImageChainUnittest CreateEffect_Blur_GetPixelMap_CPU start";
249 
250     // create from PixelMap
251     Media::InitializationOptions opts;
252     opts.size.width = 1;
253     opts.size.height = 1;
254     opts.editable = true;
255     auto uniPixelMap = Media::PixelMap::Create(opts);
256     ASSERT_NE(uniPixelMap, nullptr);
257 
258     std::shared_ptr<Media::PixelMap> srcPixelMap(std::move(uniPixelMap));
259     SkImageInfo imageInfo = SkImageInfo::Make(srcPixelMap->GetWidth(), srcPixelMap->GetHeight(),
260         SkColorType::kRGBA_8888_SkColorType,
261         static_cast<SkAlphaType>(srcPixelMap->GetAlphaType()));
262 
263     auto skImageChain = std::make_shared<SKImageChain>(srcPixelMap);
264     ASSERT_NE(skImageChain, nullptr);
265 
266     auto filterBlur = Rosen::SKImageFilterFactory::Blur(0.5);
267     ASSERT_NE(filterBlur, nullptr);
268     skImageChain->SetFilters(filterBlur);
269 
270     skImageChain->ForceCPU(true);
271     skImageChain->Draw();
272 
273     ASSERT_NE(skImageChain->GetPixelMap(), nullptr);
274 }
275 
276 HWTEST_F(SKImageChainUnittest, CreateEffect_Blur_GetPixelMap_CPU_10000, TestSize.Level1)
277 {
278     GTEST_LOG_(INFO) << "SKImageChainUnittest CreateEffect_Blur_GetPixelMap_CPU_10000 start";
279 
280     for (int i = 0;i < 10000; i++) {
281         // create from PixelMap
282         Media::InitializationOptions opts;
283         opts.size.width = 1;
284         opts.size.height = 1;
285         opts.editable = true;
286         auto uniPixelMap = Media::PixelMap::Create(opts);
287         ASSERT_NE(uniPixelMap, nullptr);
288 
289         std::shared_ptr<Media::PixelMap> srcPixelMap(std::move(uniPixelMap));
290         SkImageInfo imageInfo = SkImageInfo::Make(srcPixelMap->GetWidth(), srcPixelMap->GetHeight(),
291             SkColorType::kRGBA_8888_SkColorType,
292             static_cast<SkAlphaType>(srcPixelMap->GetAlphaType()));
293 
294         auto skImageChain = std::make_shared<SKImageChain>(srcPixelMap);
295         ASSERT_NE(skImageChain, nullptr);
296 
297         auto filterBlur = Rosen::SKImageFilterFactory::Blur(0.5);
298         ASSERT_NE(filterBlur, nullptr);
299         skImageChain->SetFilters(filterBlur);
300 
301         skImageChain->ForceCPU(true);
302         skImageChain->Draw();
303 
304         ASSERT_NE(skImageChain->GetPixelMap(), nullptr);
305     }
306 }
307 
308 HWTEST_F(SKImageChainUnittest, CreateEffect_Blur_GetPixelMap_GPU, TestSize.Level1)
309 {
310     GTEST_LOG_(INFO) << "SKImageChainUnittest CreateEffect_Blur_GetPixelMap_GPU start";
311 
312     // create from PixelMap
313     Media::InitializationOptions opts;
314     opts.size.width = 1;
315     opts.size.height = 1;
316     opts.editable = true;
317     auto uniPixelMap = Media::PixelMap::Create(opts);
318     ASSERT_NE(uniPixelMap, nullptr);
319 
320     std::shared_ptr<Media::PixelMap> srcPixelMap(std::move(uniPixelMap));
321     SkImageInfo imageInfo = SkImageInfo::Make(srcPixelMap->GetWidth(), srcPixelMap->GetHeight(),
322         SkColorType::kRGBA_8888_SkColorType,
323         static_cast<SkAlphaType>(srcPixelMap->GetAlphaType()));
324 
325     auto skImageChain = std::make_shared<SKImageChain>(srcPixelMap);
326     ASSERT_NE(skImageChain, nullptr);
327 
328     auto filterBlur = Rosen::SKImageFilterFactory::Blur(0.5);
329     ASSERT_NE(filterBlur, nullptr);
330     skImageChain->SetFilters(filterBlur);
331 
332     skImageChain->ForceCPU(false);
333     skImageChain->Draw();
334 
335     ASSERT_NE(skImageChain->GetPixelMap(), nullptr);
336 }
337 
338 HWTEST_F(SKImageChainUnittest, CreateEffect_Blur_GetPixelMap_GPU_100, TestSize.Level1)
339 {
340     GTEST_LOG_(INFO) << "SKImageChainUnittest CreateEffect_Blur_GetPixelMap_GPU_100 start";
341 
342     for (int i = 0;i < 100; i++) {
343         // create from PixelMap
344         Media::InitializationOptions opts;
345         opts.size.width = 1;
346         opts.size.height = 1;
347         opts.editable = true;
348         auto uniPixelMap = Media::PixelMap::Create(opts);
349         ASSERT_NE(uniPixelMap, nullptr);
350 
351         std::shared_ptr<Media::PixelMap> srcPixelMap(std::move(uniPixelMap));
352         SkImageInfo imageInfo = SkImageInfo::Make(srcPixelMap->GetWidth(), srcPixelMap->GetHeight(),
353             SkColorType::kRGBA_8888_SkColorType,
354             static_cast<SkAlphaType>(srcPixelMap->GetAlphaType()));
355 
356         auto skImageChain = std::make_shared<SKImageChain>(srcPixelMap);
357         ASSERT_NE(skImageChain, nullptr);
358 
359         auto filterBlur = Rosen::SKImageFilterFactory::Blur(0.5);
360         ASSERT_NE(filterBlur, nullptr);
361         skImageChain->SetFilters(filterBlur);
362 
363         skImageChain->ForceCPU(false);
364         skImageChain->Draw();
365 
366         ASSERT_NE(skImageChain->GetPixelMap(), nullptr);
367     }
368 }
369 
370 /**
371  * @tc.name: GetPixelMapTest001
372  * @tc.desc: test GetPixelMap
373  * @tc.type: FUNC
374  * @tc.require:
375  * @tc.author:
376  */
377 HWTEST_F(SKImageChainUnittest, GetPixelMapTest001, TestSize.Level1)
378 {
379     GTEST_LOG_(INFO) << "SKImageChainUnittest GetPixelMapTest001 start";
380 
381     auto skImageChain = std::make_shared<SKImageChain>(nullptr, nullptr);
382     ASSERT_NE(skImageChain, nullptr);
383 
384     ASSERT_EQ(skImageChain->GetPixelMap(), nullptr);
385 }
386 
387 /**
388  * @tc.name: SetFiltersTest001
389  * @tc.desc: test SetFilters
390  * @tc.type: FUNC
391  * @tc.require:
392  * @tc.author:
393  */
394 HWTEST_F(SKImageChainUnittest, SetTest001, TestSize.Level1)
395 {
396     auto skImageChain = std::make_shared<SKImageChain>(nullptr, nullptr);
397     ASSERT_NE(skImageChain, nullptr);
398 
399     auto filterBlur = Rosen::SKImageFilterFactory::Blur(0.5);
400     ASSERT_NE(filterBlur, nullptr);
401     skImageChain->SetFilters(filterBlur);
402 
403     auto filterBrightness = Rosen::SKImageFilterFactory::Brightness(0.5);
404     ASSERT_NE(filterBrightness, nullptr);
405     skImageChain->SetFilters(filterBrightness);
406 }
407 
408 /**
409  * @tc.name: SetClipTest001
410  * @tc.desc: test Set Clip Functions
411  * @tc.type: FUNC
412  * @tc.require:
413  * @tc.author:
414  */
415 HWTEST_F(SKImageChainUnittest, SetClipTest001, TestSize.Level1)
416 {
417     // create from PixelMap
418     Media::InitializationOptions opts;
419     opts.size.width = 1;
420     opts.size.height = 1;
421     opts.editable = true;
422     auto uniPixelMap = Media::PixelMap::Create(opts);
423     ASSERT_NE(uniPixelMap, nullptr);
424 
425     std::shared_ptr<Media::PixelMap> srcPixelMap(std::move(uniPixelMap));
426     auto skImageChain = std::make_shared<SKImageChain>(srcPixelMap);
427     ASSERT_NE(skImageChain, nullptr);
428 
429     SkRect rect = SkRect::MakeEmpty();
430     SkPath *path = new SkPath();
431     SkRRect *rRect = new SkRRect();
432     skImageChain->SetClipRect(&rect);
433     skImageChain->Draw();
434     skImageChain->SetClipRect(nullptr);
435 
436     skImageChain->SetClipPath(path);
437     skImageChain->Draw();
438     skImageChain->SetClipPath(nullptr);
439 
440     skImageChain->SetClipRRect(rRect);
441     skImageChain->Draw();
442 
443     delete path;
444     delete rRect;
445 }
446 
447 /**
448  * @tc.name: DestroyGPUCanvasTest001
449  * @tc.desc: test DestroyGPUCanvas
450  * @tc.type: FUNC
451  * @tc.require:
452  * @tc.author:
453  */
454 HWTEST_F(SKImageChainUnittest, DestroyGPUCanvasTest001, TestSize.Level1)
455 {
456     // create from PixelMap
457     Media::InitializationOptions opts;
458     opts.size.width = 1;
459     opts.size.height = 1;
460     opts.editable = true;
461     auto uniPixelMap = Media::PixelMap::Create(opts);
462     ASSERT_NE(uniPixelMap, nullptr);
463 
464     std::shared_ptr<Media::PixelMap> srcPixelMap(std::move(uniPixelMap));
465     auto skImageChain = std::make_shared<SKImageChain>(srcPixelMap);
466     ASSERT_NE(skImageChain, nullptr);
467 
468     SkRect rect = SkRect::MakeEmpty();
469     SkPath *path = new SkPath();
470     SkRRect *rRect = new SkRRect();
471     skImageChain->SetClipRect(&rect);
472     skImageChain->ForceCPU(false);
473     EXPECT_EQ(skImageChain->Draw(), DrawError::ERR_OK);
474 
475     delete path;
476     delete rRect;
477 }
478 } // namespace Rosen
479 } // namespace OHOS