• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 #include <gtest/gtest.h>
16 #include "webp_encoder.h"
17 #include "image_source.h"
18 #include "buffer_packer_stream.h"
19 
20 using namespace testing::ext;
21 using namespace OHOS::Media;
22 namespace OHOS {
23 namespace ImagePlugin {
24 class WebpEncoderTest : public testing::Test {
25 public:
WebpEncoderTest()26     WebpEncoderTest() {}
~WebpEncoderTest()27     ~WebpEncoderTest() {}
28 };
29 
30 /**
31  * @tc.name: WebpEncoderTest001
32  * @tc.desc: Test of WebpEncoder
33  * @tc.type: FUNC
34  */
35 HWTEST_F(WebpEncoderTest, WebpEncoderTest001, TestSize.Level3)
36 {
37     GTEST_LOG_(INFO) << "WebpEncoderTest: WebpEncoderTest001 start";
38     auto webpEncoder = std::make_shared<WebpEncoder>();
39     bool result = (webpEncoder != nullptr);
40     ASSERT_EQ(result, true);
41     GTEST_LOG_(INFO) << "WebpEncoderTest: WebpEncoderTest001 end";
42 }
43 
44 /**
45  * @tc.name: StartEncode001
46  * @tc.desc: Test of StartEncode
47  * @tc.type: FUNC
48  */
49 HWTEST_F(WebpEncoderTest, StartEncode001, TestSize.Level3)
50 {
51     GTEST_LOG_(INFO) << "WebpEncoderTest: StartEncode001 start";
52     auto webpEncoder = std::make_shared<WebpEncoder>();
53     PlEncodeOptions plOpts;
54     auto outputData = std::make_unique<uint8_t[]>(1000);
55     auto maxSize = 10;
56     auto stream = std::make_shared<BufferPackerStream>(outputData.get(), maxSize);
57     webpEncoder->StartEncode(*stream.get(), plOpts);
58     bool result = (webpEncoder != nullptr);
59     ASSERT_EQ(result, true);
60     GTEST_LOG_(INFO) << "WebpEncoderTest: StartEncode001 end";
61 }
62 
63 /**
64  * @tc.name: AddImage001
65  * @tc.desc: Test of AddImage
66  * @tc.type: FUNC
67  */
68 HWTEST_F(WebpEncoderTest, AddImage001, TestSize.Level3)
69 {
70     GTEST_LOG_(INFO) << "WebpEncoderTest: AddImage001 start";
71     auto webpEncoder = std::make_shared<WebpEncoder>();
72     Media::InitializationOptions opts;
73     opts.size.width = 10.f;
74     opts.size.height = 10.f;
75     opts.editable = true;
76     auto pixelMap = Media::PixelMap::Create(opts);
77     webpEncoder->AddImage(*pixelMap.get());
78     bool result = (webpEncoder != nullptr);
79     ASSERT_EQ(result, true);
80     GTEST_LOG_(INFO) << "WebpEncoderTest: AddImage001 end";
81 }
82 
83 /**
84  * @tc.name: AddImage002
85  * @tc.desc: Test of AddImage
86  * @tc.type: FUNC
87  */
88 HWTEST_F(WebpEncoderTest, AddImage002, TestSize.Level3)
89 {
90     GTEST_LOG_(INFO) << "WebpEncoderTest: AddImage002 start";
91     auto webpEncoder = std::make_shared<WebpEncoder>();
92     Media::InitializationOptions opts;
93     opts.size.width = 10.f;
94     opts.size.height = 10.f;
95     opts.editable = true;
96     auto pixelMap1 = Media::PixelMap::Create(opts);
97     auto pixelMap2 = Media::PixelMap::Create(opts);
98     webpEncoder->AddImage(*pixelMap1.get());
99     webpEncoder->AddImage(*pixelMap2.get());
100     bool result = (webpEncoder != nullptr);
101     ASSERT_EQ(result, true);
102     GTEST_LOG_(INFO) << "WebpEncoderTest: AddImage002 end";
103 }
104 
105 /**
106  * @tc.name: FinalizeEncode001
107  * @tc.desc: pixelMaps_ is empty
108  * @tc.type: FUNC
109  */
110 HWTEST_F(WebpEncoderTest, FinalizeEncode001, TestSize.Level3)
111 {
112     GTEST_LOG_(INFO) << "WebpEncoderTest: FinalizeEncode001 start";
113     auto webpEncoder = std::make_shared<WebpEncoder>();
114     webpEncoder->FinalizeEncode();
115     bool result = (webpEncoder != nullptr);
116     ASSERT_EQ(result, true);
117     GTEST_LOG_(INFO) << "WebpEncoderTest: FinalizeEncode001 end";
118 }
119 
120 /**
121  * @tc.name: FinalizeEncode002
122  * @tc.desc: The first branch of SetEncodeConfig
123  * @tc.type: FUNC
124  */
125 HWTEST_F(WebpEncoderTest, FinalizeEncode002, TestSize.Level3)
126 {
127     GTEST_LOG_(INFO) << "WebpEncoderTest: FinalizeEncode002 start";
128     auto webpEncoder = std::make_shared<WebpEncoder>();
129     Media::InitializationOptions opts;
130     opts.size.width = 10.f;
131     opts.size.height = 10.f;
132     opts.editable = true;
133     auto pixelMap = Media::PixelMap::Create(opts);
134     pixelMap->SetPixelsAddr(nullptr, nullptr, 10, AllocatorType::HEAP_ALLOC, nullptr);
135     webpEncoder->AddImage(*pixelMap.get());
136     webpEncoder->FinalizeEncode();
137     bool result = (webpEncoder != nullptr);
138     ASSERT_EQ(result, true);
139     GTEST_LOG_(INFO) << "WebpEncoderTest: FinalizeEncode002 end";
140 }
141 
142 /**
143  * @tc.name: FinalizeEncode003
144  * @tc.desc: The first case of CheckEncodeFormat
145  * @tc.type: FUNC
146  */
147 HWTEST_F(WebpEncoderTest, FinalizeEncode003, TestSize.Level3)
148 {
149     GTEST_LOG_(INFO) << "WebpEncoderTest: FinalizeEncode003 start";
150     auto webpEncoder = std::make_shared<WebpEncoder>();
151     PlEncodeOptions plOpts;
152     auto outputData = std::make_unique<uint8_t[]>(1000);
153     auto maxSize = 10;
154     auto stream = std::make_shared<BufferPackerStream>(outputData.get(), maxSize);
155     webpEncoder->StartEncode(*stream.get(), plOpts);
156     Media::InitializationOptions opts;
157     opts.alphaType = AlphaType::IMAGE_ALPHA_TYPE_UNKNOWN;
158     opts.pixelFormat = PixelFormat::RGBA_8888;
159     opts.size.width = 10.f;
160     opts.size.height = 10.f;
161     opts.editable = true;
162     auto pixelMap = Media::PixelMap::Create(opts);
163     webpEncoder->AddImage(*pixelMap.get());
164     webpEncoder->FinalizeEncode();
165     bool result = (webpEncoder != nullptr);
166     ASSERT_EQ(result, true);
167     GTEST_LOG_(INFO) << "WebpEncoderTest: FinalizeEncode003 end";
168 }
169 
170 /**
171  * @tc.name: FinalizeEncode004
172  * @tc.desc: The first case of CheckEncodeFormat
173  * @tc.type: FUNC
174  */
175 HWTEST_F(WebpEncoderTest, FinalizeEncode004, TestSize.Level3)
176 {
177     GTEST_LOG_(INFO) << "WebpEncoderTest: FinalizeEncode004 start";
178     auto webpEncoder = std::make_shared<WebpEncoder>();
179     PlEncodeOptions plOpts;
180     auto outputData = std::make_unique<uint8_t[]>(1000);
181     auto maxSize = 10;
182     auto stream = std::make_shared<BufferPackerStream>(outputData.get(), maxSize);
183     webpEncoder->StartEncode(*stream.get(), plOpts);
184     Media::InitializationOptions opts;
185     opts.alphaType = AlphaType::IMAGE_ALPHA_TYPE_OPAQUE;
186     opts.pixelFormat = PixelFormat::RGBA_8888;
187     opts.size.width = 10.f;
188     opts.size.height = 10.f;
189     opts.editable = true;
190     auto pixelMap = Media::PixelMap::Create(opts);
191     webpEncoder->AddImage(*pixelMap.get());
192     webpEncoder->FinalizeEncode();
193     bool result = (webpEncoder != nullptr);
194     ASSERT_EQ(result, true);
195     GTEST_LOG_(INFO) << "WebpEncoderTest: FinalizeEncode004 end";
196 }
197 
198 /**
199  * @tc.name: FinalizeEncode005
200  * @tc.desc: The first case of CheckEncodeFormat
201  * @tc.type: FUNC
202  */
203 HWTEST_F(WebpEncoderTest, FinalizeEncode005, TestSize.Level3)
204 {
205     GTEST_LOG_(INFO) << "WebpEncoderTest: FinalizeEncode005 start";
206     auto webpEncoder = std::make_shared<WebpEncoder>();
207     PlEncodeOptions plOpts;
208     auto outputData = std::make_unique<uint8_t[]>(1000);
209     auto maxSize = 10;
210     auto stream = std::make_shared<BufferPackerStream>(outputData.get(), maxSize);
211     webpEncoder->StartEncode(*stream.get(), plOpts);
212     Media::InitializationOptions opts;
213     opts.alphaType = AlphaType::IMAGE_ALPHA_TYPE_UNPREMUL;
214     opts.pixelFormat = PixelFormat::RGBA_8888;
215     opts.size.width = 10.f;
216     opts.size.height = 10.f;
217     opts.editable = true;
218     auto pixelMap = Media::PixelMap::Create(opts);
219     pixelMap->SetPixelsAddr(nullptr, nullptr, 10, AllocatorType::HEAP_ALLOC, nullptr);
220     webpEncoder->AddImage(*pixelMap.get());
221     webpEncoder->FinalizeEncode();
222     bool result = (webpEncoder != nullptr);
223     ASSERT_EQ(result, true);
224     GTEST_LOG_(INFO) << "WebpEncoderTest: FinalizeEncode005 end";
225 }
226 
227 
228 /**
229  * @tc.name: FinalizeEncode006
230  * @tc.desc: The first case of CheckEncodeFormat
231  * @tc.type: FUNC
232  */
233 HWTEST_F(WebpEncoderTest, FinalizeEncode006, TestSize.Level3)
234 {
235     GTEST_LOG_(INFO) << "WebpEncoderTest: FinalizeEncode006 start";
236     auto webpEncoder = std::make_shared<WebpEncoder>();
237     PlEncodeOptions plOpts;
238     auto outputData = std::make_unique<uint8_t[]>(1000);
239     auto maxSize = 10;
240     auto stream = std::make_shared<BufferPackerStream>(outputData.get(), maxSize);
241     webpEncoder->StartEncode(*stream.get(), plOpts);
242     Media::InitializationOptions opts;
243     opts.alphaType = AlphaType::IMAGE_ALPHA_TYPE_PREMUL;
244     opts.pixelFormat = PixelFormat::RGBA_8888;
245     opts.size.width = 10.f;
246     opts.size.height = 10.f;
247     opts.editable = true;
248     auto pixelMap = Media::PixelMap::Create(opts);
249     pixelMap->SetPixelsAddr(nullptr, nullptr, 10, AllocatorType::HEAP_ALLOC, nullptr);
250     webpEncoder->AddImage(*pixelMap.get());
251     webpEncoder->FinalizeEncode();
252     bool result = (webpEncoder != nullptr);
253     ASSERT_EQ(result, true);
254     GTEST_LOG_(INFO) << "WebpEncoderTest: FinalizeEncode006 end";
255 }
256 
257 /**
258  * @tc.name: FinalizeEncode007
259  * @tc.desc: The second case of CheckEncodeFormat
260  * @tc.type: FUNC
261  */
262 HWTEST_F(WebpEncoderTest, FinalizeEncode007, TestSize.Level3)
263 {
264     GTEST_LOG_(INFO) << "WebpEncoderTest: FinalizeEncode007 start";
265     auto webpEncoder = std::make_shared<WebpEncoder>();
266     PlEncodeOptions plOpts;
267     auto outputData = std::make_unique<uint8_t[]>(1000);
268     auto maxSize = 10;
269     auto stream = std::make_shared<BufferPackerStream>(outputData.get(), maxSize);
270     webpEncoder->StartEncode(*stream.get(), plOpts);
271     Media::InitializationOptions opts;
272     opts.alphaType = AlphaType::IMAGE_ALPHA_TYPE_OPAQUE;
273     opts.pixelFormat = PixelFormat::BGRA_8888;
274     opts.size.width = 10.f;
275     opts.size.height = 10.f;
276     opts.editable = true;
277     auto pixelMap = Media::PixelMap::Create(opts);
278     webpEncoder->AddImage(*pixelMap.get());
279     webpEncoder->FinalizeEncode();
280     bool result = (webpEncoder != nullptr);
281     ASSERT_EQ(result, true);
282     GTEST_LOG_(INFO) << "WebpEncoderTest: FinalizeEncode007 end";
283 }
284 
285 /**
286  * @tc.name: FinalizeEncode008
287  * @tc.desc: The second case of CheckEncodeFormat
288  * @tc.type: FUNC
289  */
290 HWTEST_F(WebpEncoderTest, FinalizeEncode008, TestSize.Level3)
291 {
292     GTEST_LOG_(INFO) << "WebpEncoderTest: FinalizeEncode008 start";
293     auto webpEncoder = std::make_shared<WebpEncoder>();
294     PlEncodeOptions plOpts;
295     auto outputData = std::make_unique<uint8_t[]>(1000);
296     auto maxSize = 10;
297     auto stream = std::make_shared<BufferPackerStream>(outputData.get(), maxSize);
298     webpEncoder->StartEncode(*stream.get(), plOpts);
299     Media::InitializationOptions opts;
300     opts.alphaType = AlphaType::IMAGE_ALPHA_TYPE_PREMUL;
301     opts.pixelFormat = PixelFormat::BGRA_8888;
302     opts.size.width = 10.f;
303     opts.size.height = 10.f;
304     opts.editable = true;
305     auto pixelMap = Media::PixelMap::Create(opts);
306     webpEncoder->AddImage(*pixelMap.get());
307     webpEncoder->FinalizeEncode();
308     bool result = (webpEncoder != nullptr);
309     ASSERT_EQ(result, true);
310     GTEST_LOG_(INFO) << "WebpEncoderTest: FinalizeEncode008 end";
311 }
312 
313 /**
314  * @tc.name: FinalizeEncode009
315  * @tc.desc: The second case of CheckEncodeFormat
316  * @tc.type: FUNC
317  */
318 HWTEST_F(WebpEncoderTest, FinalizeEncode009, TestSize.Level3)
319 {
320     GTEST_LOG_(INFO) << "WebpEncoderTest: FinalizeEncode009 start";
321     auto webpEncoder = std::make_shared<WebpEncoder>();
322     PlEncodeOptions plOpts;
323     auto outputData = std::make_unique<uint8_t[]>(1000);
324     auto maxSize = 10;
325     auto stream = std::make_shared<BufferPackerStream>(outputData.get(), maxSize);
326     webpEncoder->StartEncode(*stream.get(), plOpts);
327     Media::InitializationOptions opts;
328     opts.alphaType = AlphaType::IMAGE_ALPHA_TYPE_OPAQUE;
329     opts.pixelFormat = PixelFormat::BGRA_8888;
330     opts.size.width = 10.f;
331     opts.size.height = 10.f;
332     opts.editable = true;
333     auto pixelMap = Media::PixelMap::Create(opts);
334     webpEncoder->AddImage(*pixelMap.get());
335     webpEncoder->FinalizeEncode();
336     bool result = (webpEncoder != nullptr);
337     ASSERT_EQ(result, true);
338     GTEST_LOG_(INFO) << "WebpEncoderTest: FinalizeEncode009 end";
339 }
340 
341 /**
342  * @tc.name: FinalizeEncode0010
343  * @tc.desc: The third case of CheckEncodeFormat
344  * @tc.type: FUNC
345  */
346 HWTEST_F(WebpEncoderTest, FinalizeEncode0010, TestSize.Level3)
347 {
348     GTEST_LOG_(INFO) << "WebpEncoderTest: FinalizeEncode0010 start";
349     auto webpEncoder = std::make_shared<WebpEncoder>();
350     PlEncodeOptions plOpts;
351     auto outputData = std::make_unique<uint8_t[]>(1000);
352     auto maxSize = 10;
353     auto stream = std::make_shared<BufferPackerStream>(outputData.get(), maxSize);
354     webpEncoder->StartEncode(*stream.get(), plOpts);
355     Media::InitializationOptions opts;
356     opts.pixelFormat = PixelFormat::RGBA_F16;
357     opts.alphaType = AlphaType::IMAGE_ALPHA_TYPE_OPAQUE;
358     opts.size.width = 10.f;
359     opts.size.height = 10.f;
360     opts.editable = true;
361     auto pixelMap = Media::PixelMap::Create(opts);
362     webpEncoder->AddImage(*pixelMap.get());
363     webpEncoder->FinalizeEncode();
364     bool result = (webpEncoder != nullptr);
365     ASSERT_EQ(result, true);
366     GTEST_LOG_(INFO) << "WebpEncoderTest: FinalizeEncode0010 end";
367 }
368 
369 /**
370  * @tc.name: FinalizeEncode011
371  * @tc.desc: The third case of CheckEncodeFormat
372  * @tc.type: FUNC
373  */
374 HWTEST_F(WebpEncoderTest, FinalizeEncode011, TestSize.Level3)
375 {
376     GTEST_LOG_(INFO) << "WebpEncoderTest: FinalizeEncode011 start";
377     auto webpEncoder = std::make_shared<WebpEncoder>();
378     PlEncodeOptions plOpts;
379     auto outputData = std::make_unique<uint8_t[]>(1000);
380     auto maxSize = 10;
381     auto stream = std::make_shared<BufferPackerStream>(outputData.get(), maxSize);
382     webpEncoder->StartEncode(*stream.get(), plOpts);
383     Media::InitializationOptions opts;
384     opts.pixelFormat = PixelFormat::RGBA_F16;
385     opts.alphaType = AlphaType::IMAGE_ALPHA_TYPE_UNPREMUL;
386     opts.size.width = 10.f;
387     opts.size.height = 10.f;
388     opts.editable = true;
389     auto pixelMap = Media::PixelMap::Create(opts);
390     webpEncoder->AddImage(*pixelMap.get());
391     webpEncoder->FinalizeEncode();
392     bool result = (webpEncoder != nullptr);
393     ASSERT_EQ(result, true);
394     GTEST_LOG_(INFO) << "WebpEncoderTest: FinalizeEncode011 end";
395 }
396 
397 /**
398  * @tc.name: FinalizeEncode012
399  * @tc.desc: The third case of CheckEncodeFormat
400  * @tc.type: FUNC
401  */
402 HWTEST_F(WebpEncoderTest, FinalizeEncode012, TestSize.Level3)
403 {
404     GTEST_LOG_(INFO) << "WebpEncoderTest: FinalizeEncode012 start";
405     auto webpEncoder = std::make_shared<WebpEncoder>();
406     PlEncodeOptions plOpts;
407     auto outputData = std::make_unique<uint8_t[]>(1000);
408     auto maxSize = 10;
409     auto stream = std::make_shared<BufferPackerStream>(outputData.get(), maxSize);
410     webpEncoder->StartEncode(*stream.get(), plOpts);
411     Media::InitializationOptions opts;
412     opts.pixelFormat = PixelFormat::RGBA_F16;
413     opts.alphaType = AlphaType::IMAGE_ALPHA_TYPE_PREMUL;
414     opts.size.width = 10.f;
415     opts.size.height = 10.f;
416     opts.editable = true;
417     auto pixelMap = Media::PixelMap::Create(opts);
418     webpEncoder->AddImage(*pixelMap.get());
419     webpEncoder->FinalizeEncode();
420     bool result = (webpEncoder != nullptr);
421     ASSERT_EQ(result, true);
422     GTEST_LOG_(INFO) << "WebpEncoderTest: FinalizeEncode012 end";
423 }
424 
425 /**
426  * @tc.name: FinalizeEncode013
427  * @tc.desc: The fouth case of CheckEncodeFormat
428  * @tc.type: FUNC
429  */
430 HWTEST_F(WebpEncoderTest, FinalizeEncode013, TestSize.Level3)
431 {
432     GTEST_LOG_(INFO) << "WebpEncoderTest: FinalizeEncode013 start";
433     auto webpEncoder = std::make_shared<WebpEncoder>();
434     PlEncodeOptions plOpts;
435     auto outputData = std::make_unique<uint8_t[]>(1000);
436     auto maxSize = 10;
437     auto stream = std::make_shared<BufferPackerStream>(outputData.get(), maxSize);
438     webpEncoder->StartEncode(*stream.get(), plOpts);
439     Media::InitializationOptions opts;
440     opts.pixelFormat = PixelFormat::ARGB_8888;
441     opts.alphaType = AlphaType::IMAGE_ALPHA_TYPE_OPAQUE;
442     opts.size.width = 10.f;
443     opts.size.height = 10.f;
444     opts.editable = true;
445     auto pixelMap = Media::PixelMap::Create(opts);
446     webpEncoder->AddImage(*pixelMap.get());
447     webpEncoder->FinalizeEncode();
448     bool result = (webpEncoder != nullptr);
449     ASSERT_EQ(result, true);
450     GTEST_LOG_(INFO) << "WebpEncoderTest: FinalizeEncode013 end";
451 }
452 
453 /**
454  * @tc.name: FinalizeEncode014
455  * @tc.desc: The fouth case of CheckEncodeFormat
456  * @tc.type: FUNC
457  */
458 HWTEST_F(WebpEncoderTest, FinalizeEncode014, TestSize.Level3)
459 {
460     GTEST_LOG_(INFO) << "WebpEncoderTest: FinalizeEncode014 start";
461     auto webpEncoder = std::make_shared<WebpEncoder>();
462     PlEncodeOptions plOpts;
463     auto outputData = std::make_unique<uint8_t[]>(1000);
464     auto maxSize = 10;
465     auto stream = std::make_shared<BufferPackerStream>(outputData.get(), maxSize);
466     webpEncoder->StartEncode(*stream.get(), plOpts);
467     Media::InitializationOptions opts;
468     opts.pixelFormat = PixelFormat::ARGB_8888;
469     opts.alphaType = AlphaType::IMAGE_ALPHA_TYPE_UNPREMUL;
470     opts.size.width = 10.f;
471     opts.size.height = 10.f;
472     opts.editable = true;
473     auto pixelMap = Media::PixelMap::Create(opts);
474     webpEncoder->AddImage(*pixelMap.get());
475     webpEncoder->FinalizeEncode();
476     bool result = (webpEncoder != nullptr);
477     ASSERT_EQ(result, true);
478     GTEST_LOG_(INFO) << "WebpEncoderTest: FinalizeEncode014 end";
479 }
480 
481 /**
482  * @tc.name: FinalizeEncode015
483  * @tc.desc: The fouth case of CheckEncodeFormat
484  * @tc.type: FUNC
485  */
486 HWTEST_F(WebpEncoderTest, FinalizeEncode015, TestSize.Level3)
487 {
488     GTEST_LOG_(INFO) << "WebpEncoderTest: FinalizeEncode015 start";
489     auto webpEncoder = std::make_shared<WebpEncoder>();
490     PlEncodeOptions plOpts;
491     auto outputData = std::make_unique<uint8_t[]>(1000);
492     auto maxSize = 10;
493     auto stream = std::make_shared<BufferPackerStream>(outputData.get(), maxSize);
494     webpEncoder->StartEncode(*stream.get(), plOpts);
495     Media::InitializationOptions opts;
496     opts.pixelFormat = PixelFormat::ARGB_8888;
497     opts.alphaType = AlphaType::IMAGE_ALPHA_TYPE_PREMUL;
498     opts.size.width = 10.f;
499     opts.size.height = 10.f;
500     opts.editable = true;
501     auto pixelMap = Media::PixelMap::Create(opts);
502     webpEncoder->AddImage(*pixelMap.get());
503     webpEncoder->FinalizeEncode();
504     bool result = (webpEncoder != nullptr);
505     ASSERT_EQ(result, true);
506     GTEST_LOG_(INFO) << "WebpEncoderTest: FinalizeEncode015 end";
507 }
508 
509 /**
510  * @tc.name: FinalizeEncode016
511  * @tc.desc: The fifth case of CheckEncodeFormat
512  * @tc.type: FUNC
513  */
514 HWTEST_F(WebpEncoderTest, FinalizeEncode016, TestSize.Level3)
515 {
516     GTEST_LOG_(INFO) << "WebpEncoderTest: FinalizeEncode016 start";
517     auto webpEncoder = std::make_shared<WebpEncoder>();
518     PlEncodeOptions plOpts;
519     auto outputData = std::make_unique<uint8_t[]>(1000);
520     auto maxSize = 10;
521     auto stream = std::make_shared<BufferPackerStream>(outputData.get(), maxSize);
522     webpEncoder->StartEncode(*stream.get(), plOpts);
523     Media::InitializationOptions opts;
524     opts.pixelFormat = PixelFormat::RGB_888;
525     opts.size.width = 10.f;
526     opts.size.height = 10.f;
527     opts.editable = true;
528     auto pixelMap = Media::PixelMap::Create(opts);
529     webpEncoder->AddImage(*pixelMap.get());
530     webpEncoder->FinalizeEncode();
531     bool result = (webpEncoder != nullptr);
532     ASSERT_EQ(result, true);
533     GTEST_LOG_(INFO) << "WebpEncoderTest: FinalizeEncode016 end";
534 }
535 
536 /**
537  * @tc.name: FinalizeEncode017
538  * @tc.desc: The sixth case of CheckEncodeFormat
539  * @tc.type: FUNC
540  */
541 HWTEST_F(WebpEncoderTest, FinalizeEncode017, TestSize.Level3)
542 {
543     GTEST_LOG_(INFO) << "WebpEncoderTest: FinalizeEncode017 start";
544     auto webpEncoder = std::make_shared<WebpEncoder>();
545     PlEncodeOptions plOpts;
546     auto outputData = std::make_unique<uint8_t[]>(1000);
547     auto maxSize = 10;
548     auto stream = std::make_shared<BufferPackerStream>(outputData.get(), maxSize);
549     webpEncoder->StartEncode(*stream.get(), plOpts);
550     Media::InitializationOptions opts;
551     opts.pixelFormat = PixelFormat::RGB_565;
552     opts.alphaType = AlphaType::IMAGE_ALPHA_TYPE_PREMUL;
553     opts.size.width = 10.f;
554     opts.size.height = 10.f;
555     opts.editable = true;
556     auto pixelMap = Media::PixelMap::Create(opts);
557     webpEncoder->AddImage(*pixelMap.get());
558     webpEncoder->FinalizeEncode();
559     bool result = (webpEncoder != nullptr);
560     ASSERT_EQ(result, true);
561     GTEST_LOG_(INFO) << "WebpEncoderTest: FinalizeEncode017 end";
562 }
563 
564 /**
565  * @tc.name: FinalizeEncode018
566  * @tc.desc: The sixth case of CheckEncodeFormat
567  * @tc.type: FUNC
568  */
569 HWTEST_F(WebpEncoderTest, FinalizeEncode018, TestSize.Level3)
570 {
571     GTEST_LOG_(INFO) << "WebpEncoderTest: FinalizeEncode018 start";
572     auto webpEncoder = std::make_shared<WebpEncoder>();
573     PlEncodeOptions plOpts;
574     auto outputData = std::make_unique<uint8_t[]>(1000);
575     auto maxSize = 10;
576     auto stream = std::make_shared<BufferPackerStream>(outputData.get(), maxSize);
577     webpEncoder->StartEncode(*stream.get(), plOpts);
578     Media::InitializationOptions opts;
579     opts.pixelFormat = PixelFormat::RGB_565;
580     opts.alphaType = AlphaType::IMAGE_ALPHA_TYPE_OPAQUE;
581     opts.size.width = 10.f;
582     opts.size.height = 10.f;
583     opts.editable = true;
584     auto pixelMap = Media::PixelMap::Create(opts);
585     webpEncoder->AddImage(*pixelMap.get());
586     webpEncoder->FinalizeEncode();
587     bool result = (webpEncoder != nullptr);
588     ASSERT_EQ(result, true);
589     GTEST_LOG_(INFO) << "WebpEncoderTest: FinalizeEncode018 end";
590 }
591 
592 /**
593  * @tc.name: FinalizeEncode019
594  * @tc.desc: The seventh case of CheckEncodeFormat
595  * @tc.type: FUNC
596  */
597 HWTEST_F(WebpEncoderTest, FinalizeEncode019, TestSize.Level3)
598 {
599     GTEST_LOG_(INFO) << "WebpEncoderTest: FinalizeEncode019 start";
600     auto webpEncoder = std::make_shared<WebpEncoder>();
601     PlEncodeOptions plOpts;
602     auto outputData = std::make_unique<uint8_t[]>(1000);
603     auto maxSize = 10;
604     auto stream = std::make_shared<BufferPackerStream>(outputData.get(), maxSize);
605     webpEncoder->StartEncode(*stream.get(), plOpts);
606     Media::InitializationOptions opts;
607     opts.pixelFormat = PixelFormat::ALPHA_8;
608     opts.size.width = 10.f;
609     opts.size.height = 10.f;
610     opts.editable = true;
611     auto pixelMap = Media::PixelMap::Create(opts);
612     webpEncoder->AddImage(*pixelMap.get());
613     webpEncoder->FinalizeEncode();
614     bool result = (webpEncoder != nullptr);
615     ASSERT_EQ(result, true);
616     GTEST_LOG_(INFO) << "WebpEncoderTest: FinalizeEncode019 end";
617 }
618 
619 /**
620  * @tc.name: FinalizeEncode0020
621  * @tc.desc: The defaut case of CheckEncodeFormat
622  * @tc.type: FUNC
623  */
624 HWTEST_F(WebpEncoderTest, FinalizeEncode0020, TestSize.Level3)
625 {
626     GTEST_LOG_(INFO) << "WebpEncoderTest: FinalizeEncode0020 start";
627     auto webpEncoder = std::make_shared<WebpEncoder>();
628     PlEncodeOptions plOpts;
629     auto outputData = std::make_unique<uint8_t[]>(1000);
630     auto maxSize = 10;
631     auto stream = std::make_shared<BufferPackerStream>(outputData.get(), maxSize);
632     webpEncoder->StartEncode(*stream.get(), plOpts);
633     Media::InitializationOptions opts;
634     opts.pixelFormat = PixelFormat::CMYK;
635     opts.size.width = 10.f;
636     opts.size.height = 10.f;
637     opts.editable = true;
638     auto pixelMap = Media::PixelMap::Create(opts);
639     webpEncoder->AddImage(*pixelMap.get());
640     webpEncoder->FinalizeEncode();
641     bool result = (webpEncoder != nullptr);
642     ASSERT_EQ(result, true);
643     GTEST_LOG_(INFO) << "WebpEncoderTest: FinalizeEncode0020 end";
644 }
645 
646 /**
647  * @tc.name: FinalizeEncode0021
648  * @tc.desc: DoTransform in DoEncode methods
649  * @tc.type: FUNC
650  */
651 HWTEST_F(WebpEncoderTest, FinalizeEncode0021, TestSize.Level3)
652 {
653     GTEST_LOG_(INFO) << "WebpEncoderTest: FinalizeEncode0021 start";
654     auto webpEncoder = std::make_shared<WebpEncoder>();
655     PlEncodeOptions plOpts;
656     auto outputData = std::make_unique<uint8_t[]>(1000);
657     auto maxSize = 10;
658     auto stream = std::make_shared<BufferPackerStream>(outputData.get(), maxSize);
659     webpEncoder->StartEncode(*stream.get(), plOpts);
660     Media::InitializationOptions opts;
661     opts.pixelFormat = PixelFormat::NV12;
662     opts.size.width = 10.f;
663     opts.size.height = 10.f;
664     opts.editable = true;
665     auto pixelMap = Media::PixelMap::Create(opts);
666     webpEncoder->AddImage(*pixelMap.get());
667     webpEncoder->FinalizeEncode();
668     bool result = (webpEncoder != nullptr);
669     ASSERT_EQ(result, true);
670     GTEST_LOG_(INFO) << "WebpEncoderTest: FinalizeEncode0021 end";
671 }
672 
673 /**
674  * @tc.name: Write001
675  * @tc.desc: Test of Write
676  * @tc.type: FUNC
677  */
678 HWTEST_F(WebpEncoderTest, Write001, TestSize.Level3)
679 {
680     GTEST_LOG_(INFO) << "WebpEncoderTest: Write001 start";
681     auto webpEncoder = std::make_shared<WebpEncoder>();
682     PlEncodeOptions plOpts;
683     auto outputData = std::make_unique<uint8_t[]>(1000);
684     auto maxSize = 10;
685     auto stream = std::make_shared<BufferPackerStream>(outputData.get(), maxSize);
686     webpEncoder->StartEncode(*stream.get(), plOpts);
687     std::unique_ptr<uint8_t[]> rgb = std::make_unique<uint8_t[]>(10);
688     webpEncoder->Write(rgb.get(), 10);
689     bool result = (webpEncoder != nullptr);
690     ASSERT_EQ(result, true);
691     GTEST_LOG_(INFO) << "WebpEncoderTest: Write001 end";
692 }
693 }
694 }