• 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 
16 #include <algorithm>
17 #include <fcntl.h>
18 #include <fstream>
19 #include <gtest/gtest.h>
20 #include <vector>
21 #include "image/abs_image_decoder.h"
22 #include "image/abs_image_format_agent.h"
23 #include "image/image_plugin_type.h"
24 #include "image_log.h"
25 #include "image_utils.h"
26 #include "image_source_util.h"
27 #include "incremental_source_stream.h"
28 #include "istream_source_stream.h"
29 #include "media_errors.h"
30 #include "pixel_map.h"
31 #include "plugin_server.h"
32 #include "post_proc.h"
33 #include "source_stream.h"
34 #include "image_source.h"
35 #include "buffer_source_stream.h"
36 #include "file_source_stream.h"
37 
38 using namespace testing::ext;
39 using namespace OHOS::Media;
40 using namespace OHOS::HiviewDFX;
41 namespace OHOS {
42 namespace Media {
43 static const std::string IMAGE_INPUT_JPEG_PATH = "/data/local/tmp/image/test.jpg";
44 
45 class ImageSourceTest : public testing::Test {
46 public:
ImageSourceTest()47     ImageSourceTest() {}
~ImageSourceTest()48     ~ImageSourceTest() {}
49 };
50 
51 /**
52  * @tc.name: GetSupportedFormats001
53  * @tc.desc: test GetSupportedFormats
54  * @tc.type: FUNC
55  */
56 HWTEST_F(ImageSourceTest, GetSupportedFormats001, TestSize.Level3)
57 {
58     GTEST_LOG_(INFO) << "ImageSourceTest: GetSupportedFormats001 start";
59     uint32_t errorCode = 0;
60     SourceOptions opts;
61     opts.formatHint = "image/jpeg";
62     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(IMAGE_INPUT_JPEG_PATH, opts, errorCode);
63     std::set<std::string> formats;
64     uint32_t ret = imageSource->GetSupportedFormats(formats);
65     ASSERT_EQ(ret, SUCCESS);
66     GTEST_LOG_(INFO) << "ImageSourceTest: GetSupportedFormats001 end";
67 }
68 
69 /**
70  * @tc.name: GetSupportedFormats002
71  * @tc.desc: test GetSupportedFormats
72  * @tc.type: FUNC
73  */
74 HWTEST_F(ImageSourceTest, GetSupportedFormats002, TestSize.Level3)
75 {
76     GTEST_LOG_(INFO) << "ImageSourceTest: GetSupportedFormats002 start";
77     uint32_t errorCode = 0;
78     SourceOptions opts;
79     opts.formatHint = "image/jpeg";
80     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(IMAGE_INPUT_JPEG_PATH, opts, errorCode);
81     std::set<std::string> formats;
82     imageSource->GetSupportedFormats(formats);
83     GTEST_LOG_(INFO) << "ImageSourceTest: GetSupportedFormats002 end";
84 }
85 
86 /**
87  * @tc.name: GetSupportedFormats003
88  * @tc.desc: test GetSupportedFormats
89  * @tc.type: FUNC
90  */
91 HWTEST_F(ImageSourceTest, GetSupportedFormats003, TestSize.Level3)
92 {
93     GTEST_LOG_(INFO) << "ImageSourceTest: GetSupportedFormats003 start";
94     uint32_t errorCode = 0;
95     SourceOptions opts;
96     opts.formatHint = "image/test.nrw";
97     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(IMAGE_INPUT_JPEG_PATH, opts, errorCode);
98     std::set<std::string> formats;
99     if (imageSource != nullptr) {
100         imageSource->GetSupportedFormats(formats);
101     }
102     GTEST_LOG_(INFO) << "ImageSourceTest: GetSupportedFormats003 end";
103 }
104 
105 /**
106  * @tc.name: CreateImageSource003
107  * @tc.desc: test CreateImageSource
108  * @tc.type: FUNC
109  */
110 HWTEST_F(ImageSourceTest, CreateImageSource003, TestSize.Level3)
111 {
112     GTEST_LOG_(INFO) << "ImageSourceTest: CreateImageSource003 start";
113     uint32_t errorCode = 0;
114     const SourceOptions opts;
115     const uint8_t *data = nullptr;
116     uint32_t size = 1;
117     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(data, size, opts, errorCode);
118     ASSERT_EQ(imageSource, nullptr);
119     GTEST_LOG_(INFO) << "ImageSourceTest: CreateImageSource003 end";
120 }
121 
122 /**
123  * @tc.name: CreateImageSource004
124  * @tc.desc: test CreateImageSource
125  * @tc.type: FUNC
126  */
127 HWTEST_F(ImageSourceTest, CreateImageSource004, TestSize.Level3)
128 {
129     GTEST_LOG_(INFO) << "ImageSourceTest: CreateImageSource004 start";
130     size_t bufferSize = 0;
131     bool ret = ImageUtils::GetFileSize(IMAGE_INPUT_JPEG_PATH, bufferSize);
132     ASSERT_EQ(ret, true);
133     uint8_t *buffer = static_cast<uint8_t *>(malloc(bufferSize));
134     ASSERT_NE(buffer, nullptr);
135     ret = OHOS::ImageSourceUtil::ReadFileToBuffer(IMAGE_INPUT_JPEG_PATH, buffer, bufferSize);
136     ASSERT_EQ(ret, true);
137     uint32_t size = 0;
138     uint32_t errorCode = 0;
139     const SourceOptions opts;
140     std::unique_ptr<ImageSource> creimagesource = ImageSource::CreateImageSource(buffer, size, opts, errorCode);
141     ASSERT_EQ(creimagesource, nullptr);
142     GTEST_LOG_(INFO) << "ImageSourceTest: CreateImageSource004 end";
143 }
144 
145 /**
146  * @tc.name: CreateImageSource005
147  * @tc.desc: test CreateImageSource
148  * @tc.type: FUNC
149  */
150 HWTEST_F(ImageSourceTest, CreateImageSource005, TestSize.Level3)
151 {
152     GTEST_LOG_(INFO) << "ImageSourceTest: CreateImageSource005 start";
153 
154     uint32_t errorCode = 0;
155     const SourceOptions opts;
156     const std::string pathName = IMAGE_INPUT_JPEG_PATH;
157     std::unique_ptr<ImageSource> creimagesource = ImageSource::CreateImageSource(pathName, opts, errorCode);
158     GTEST_LOG_(INFO) << "ImageSourceTest: CreateImageSource005 end";
159 }
160 
161 /**
162  * @tc.name: CreateImageSource006
163  * @tc.desc: test CreateImageSource
164  * @tc.type: FUNC
165  */
166 HWTEST_F(ImageSourceTest, CreateImageSource006, TestSize.Level3)
167 {
168     GTEST_LOG_(INFO) << "ImageSourceTest: CreateImageSource006 start";
169 
170     uint32_t errorCode = 0;
171     const SourceOptions opts;
172     const std::string pathName = "a";
173     std::unique_ptr<ImageSource> creimagesource = ImageSource::CreateImageSource(pathName, opts, errorCode);
174 
175     GTEST_LOG_(INFO) << "ImageSourceTest: CreateImageSource006 end";
176 }
177 
178 /**
179  * @tc.name: CreateImageSource007
180  * @tc.desc: test CreateImageSource
181  * @tc.type: FUNC
182  */
183 HWTEST_F(ImageSourceTest, CreateImageSource007, TestSize.Level3)
184 {
185     GTEST_LOG_(INFO) << "ImageSourceTest: CreateImageSource007 start";
186     uint32_t errorCode = 0;
187     const SourceOptions opts;
188     const int fd = open("/data/local/tmp/image/test.jpg", O_RDWR | O_CREAT, S_IRUSR | S_IWUSR);
189     std::unique_ptr<ImageSource> creimagesource = ImageSource::CreateImageSource(fd, opts, errorCode);
190     GTEST_LOG_(INFO) << "ImageSourceTest: CreateImageSource007 end";
191 }
192 
193 /**
194  * @tc.name: CreateImageSource008
195  * @tc.desc: test CreateImageSource
196  * @tc.type: FUNC
197  */
198 HWTEST_F(ImageSourceTest, CreateImageSource008, TestSize.Level3)
199 {
200     GTEST_LOG_(INFO) << "ImageSourceTest: CreateImageSource008 start";
201 
202     uint32_t errorCode = 0;
203     const SourceOptions opts;
204     const int fd = 0;
205     ImageSource::CreateImageSource(fd, opts, errorCode);
206     GTEST_LOG_(INFO) << "ImageSourceTest: CreateImageSource008 end";
207 }
208 
209 /**
210  * @tc.name: CreateIncrementalImageSource001
211  * @tc.desc: test CreateIncrementalImageSource
212  * @tc.type: FUNC
213  */
214 HWTEST_F(ImageSourceTest, CreateIncrementalImageSource001, TestSize.Level3)
215 {
216     GTEST_LOG_(INFO) << "ImageSourceTest: CreateIncrementalImageSource001 start";
217     uint32_t errorCode = 0;
218     const IncrementalSourceOptions opts;
219     std::unique_ptr<ImageSource> creimagesource = ImageSource::CreateIncrementalImageSource(opts, errorCode);
220     GTEST_LOG_(INFO) << "ImageSourceTest: CreateIncrementalImageSource001 end";
221 }
222 
223 /**
224  * @tc.name: CreatePixelMapEx001
225  * @tc.desc: test CreatePixelMapEx
226  * @tc.type: FUNC
227  */
228 HWTEST_F(ImageSourceTest, CreatePixelMapEx001, TestSize.Level3)
229 {
230     GTEST_LOG_(INFO) << "ImageSourceTest: CreatePixelMapEx001 start";
231 
232     uint32_t errorCode = 0;
233     IncrementalSourceOptions incOpts;
234     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateIncrementalImageSource(incOpts, errorCode);
235     uint32_t index = 1;
236     const DecodeOptions opts;
237     std::unique_ptr<PixelMap> crepixelmapex = imageSource->CreatePixelMapEx(index, opts, errorCode);
238     ASSERT_EQ(crepixelmapex, nullptr);
239 
240     GTEST_LOG_(INFO) << "ImageSourceTest: CreatePixelMapEx001 end";
241 }
242 
243 /**
244  * @tc.name: CreatePixelMapEx002
245  * @tc.desc: test CreatePixelMapEx
246  * @tc.type: FUNC
247  */
248 HWTEST_F(ImageSourceTest, CreatePixelMapEx002, TestSize.Level3)
249 {
250     GTEST_LOG_(INFO) << "ImageSourceTest: CreatePixelMapEx002 start";
251 
252     uint32_t errorCode = 0;
253     SourceOptions opts;
254     opts.formatHint = "image/jpeg";
255     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(IMAGE_INPUT_JPEG_PATH, opts, errorCode);
256     uint32_t index = 1;
257     const DecodeOptions opt;
258     std::unique_ptr<PixelMap> crepixelmapex = imageSource->CreatePixelMapEx(index, opt, errorCode);
259 
260     GTEST_LOG_(INFO) << "ImageSourceTest: CreatePixelMapEx002 end";
261 }
262 
263 /**
264  * @tc.name: CreatePixelMap001
265  * @tc.desc: test CreatePixelMap
266  * @tc.type: FUNC
267  */
268 HWTEST_F(ImageSourceTest, CreatePixelMap001, TestSize.Level3)
269 {
270     GTEST_LOG_(INFO) << "ImageSourceTest: CreatePixelMap001 start";
271 
272     uint32_t errorCode = 0;
273     IncrementalSourceOptions incOpts;
274     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateIncrementalImageSource(incOpts, errorCode);
275     uint32_t index = 1;
276     const DecodeOptions opts;
277     std::unique_ptr<PixelMap> crepixelmap = imageSource->CreatePixelMap(index, opts, errorCode);
278     ASSERT_EQ(crepixelmap, nullptr);
279 
280     GTEST_LOG_(INFO) << "ImageSourceTest: CreatePixelMap001 end";
281 }
282 
283 /**
284  * @tc.name: CreatePixelMap002
285  * @tc.desc: test CreatePixelMap
286  * @tc.type: FUNC
287  */
288 HWTEST_F(ImageSourceTest, CreatePixelMap002, TestSize.Level3)
289 {
290     GTEST_LOG_(INFO) << "ImageSourceTest: CreatePixelMap002 start";
291 
292     uint32_t errorCode = 0;
293     IncrementalSourceOptions incOpts;
294     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateIncrementalImageSource(incOpts, errorCode);
295     uint32_t index = 1;
296     const DecodeOptions opts;
297     std::unique_ptr<PixelMap> crepixelmap = imageSource->CreatePixelMap(index, opts, errorCode);
298     ASSERT_EQ(crepixelmap, nullptr);
299 
300     GTEST_LOG_(INFO) << "ImageSourceTest: CreatePixelMap002 end";
301 }
302 
303 /**
304  * @tc.name: CreateIncrementalPixelMap001
305  * @tc.desc: test CreateIncrementalPixelMap
306  * @tc.type: FUNC
307  */
308 HWTEST_F(ImageSourceTest, CreateIncrementalPixelMap001, TestSize.Level3)
309 {
310     GTEST_LOG_(INFO) << "ImageSourceTest: CreateIncrementalPixelMap001 start";
311 
312     size_t bufferSize = 0;
313     bool fileRet = ImageUtils::GetFileSize(IMAGE_INPUT_JPEG_PATH, bufferSize);
314     ASSERT_EQ(fileRet, true);
315     uint8_t *buffer = reinterpret_cast<uint8_t *>(malloc(bufferSize));
316     ASSERT_NE(buffer, nullptr);
317     fileRet = OHOS::ImageSourceUtil::ReadFileToBuffer(IMAGE_INPUT_JPEG_PATH, buffer, bufferSize);
318     ASSERT_EQ(fileRet, true);
319     uint32_t errorCode = 0;
320     IncrementalSourceOptions incOpts;
321     incOpts.incrementalMode = IncrementalMode::INCREMENTAL_DATA;
322     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateIncrementalImageSource(incOpts, errorCode);
323     ASSERT_EQ(errorCode, SUCCESS);
324 
325     DecodeOptions decodeOpts;
326     std::unique_ptr<IncrementalPixelMap> incPixelMap = imageSource->CreateIncrementalPixelMap(0, decodeOpts,
327         errorCode);
328     ASSERT_NE(incPixelMap, nullptr);
329 
330     GTEST_LOG_(INFO) << "ImageSourceTest: CreateIncrementalPixelMap001 end";
331 }
332 
333 /**
334  * @tc.name: CreateIncrementalPixelMap002
335  * @tc.desc: test CreateIncrementalPixelMap
336  * @tc.type: FUNC
337  */
338 HWTEST_F(ImageSourceTest, CreateIncrementalPixelMap002, TestSize.Level3)
339 {
340     GTEST_LOG_(INFO) << "ImageSourceTest: CreateIncrementalPixelMap002 start";
341 
342     uint32_t errorCode = 0;
343     SourceOptions opts;
344     opts.formatHint = "image/jpeg";
345     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(IMAGE_INPUT_JPEG_PATH, opts, errorCode);
346 
347     uint32_t info = 100;
348     DecodeOptions op;
349     op.sampleSize = 1;
350     imageSource->CreatePixelMap(info, op, errorCode);
351     info = -1;
352     op.sampleSize = 0;
353     imageSource->CreatePixelMap(info, op, errorCode);
354 
355     GTEST_LOG_(INFO) << "ImageSourceTest: CreateIncrementalPixelMap002 end";
356 }
357 
358 /**
359  * @tc.name: UpdateData001
360  * @tc.desc: test UpdateData
361  * @tc.type: FUNC
362  */
363 HWTEST_F(ImageSourceTest, UpdateData001, TestSize.Level3)
364 {
365     GTEST_LOG_(INFO) << "ImageSourceTest: UpdateData001 start";
366     uint32_t errorCode = 0;
367     SourceOptions opts;
368     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(IMAGE_INPUT_JPEG_PATH, opts, errorCode);
369 
370     DecodeOptions decodeOpts;
371     size_t bufferSize = 0;
372     uint8_t *buffer = reinterpret_cast<uint8_t *>(malloc(bufferSize));
373     std::unique_ptr<IncrementalPixelMap> incPixelMap = imageSource->CreateIncrementalPixelMap(0, decodeOpts,
374         errorCode);
375     ASSERT_NE(incPixelMap, nullptr);
376     uint32_t updateSize = 0;
377     srand(time(nullptr));
378     bool isCompleted = false;
379     while (updateSize < bufferSize) {
380         uint32_t updateOnceSize = rand() % 1024;
381         if (updateSize + updateOnceSize > bufferSize) {
382             updateOnceSize = bufferSize - updateSize;
383             isCompleted = true;
384         }
385         uint32_t ret = imageSource->UpdateData(buffer + updateSize, updateOnceSize, isCompleted);
386         ASSERT_EQ(ret, SUCCESS);
387         uint8_t decodeProgress = 0;
388         incPixelMap->PromoteDecoding(decodeProgress);
389         updateSize += updateOnceSize;
390     }
391     GTEST_LOG_(INFO) << "ImageSourceTest: UpdateData001 end";
392 }
393 
394  /**
395   * @tc.name: GetImageInfo001
396   * @tc.desc: test GetImageInfo
397   * @tc.type: FUNC
398   */
399 HWTEST_F(ImageSourceTest, GetImageInfo001, TestSize.Level3)
400 {
401     GTEST_LOG_(INFO) << "ImageSourceTest: GetImageInfo001 start";
402 
403     uint32_t errorCode = 0;
404     SourceOptions opts;
405     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(IMAGE_INPUT_JPEG_PATH, opts, errorCode);
406 
407     ImageInfo imageInfo;
408     uint32_t index = 1;
409     uint32_t ret = imageSource->GetImageInfo(index, imageInfo);
410     ASSERT_EQ(ret, ERR_IMAGE_DECODE_FAILED);
411     GTEST_LOG_(INFO) << "ImageSourceTest: GetImageInfo001 end";
412 }
413 
414  /**
415   * @tc.name: GetImageInfo002
416   * @tc.desc: test GetImageInfo
417   * @tc.type: FUNC
418   */
419 HWTEST_F(ImageSourceTest, GetImageInfo002, TestSize.Level3)
420 {
421     GTEST_LOG_(INFO) << "ImageSourceTest: GetImageInfo002 start";
422 
423     uint32_t errorCode = 0;
424     SourceOptions opts;
425     opts.formatHint = "image/jpeg";
426     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(IMAGE_INPUT_JPEG_PATH, opts, errorCode);
427 
428     ImageInfo imageInfo;
429     uint32_t index = 1;
430     imageSource->GetImageInfo(index, imageInfo);
431     GTEST_LOG_(INFO) << "ImageSourceTest: GetImageInfo002 end";
432 }
433 
434 /**
435  * @tc.name: GetSourceInfo001
436  * @tc.desc: test GetSourceInfo
437  * @tc.type: FUNC
438  */
439 HWTEST_F(ImageSourceTest, GetSourceInfo001, TestSize.Level3)
440 {
441     GTEST_LOG_(INFO) << "ImageSourceTest: GetSourceInfo001 start";
442     uint32_t errorCode = 0;
443     SourceOptions opts;
444     opts.formatHint = "image/jpeg";
445     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(IMAGE_INPUT_JPEG_PATH, opts, errorCode);
446     imageSource->GetSourceInfo(errorCode);
447     GTEST_LOG_(INFO) << "ImageSourceTest: GetSourceInfo001 end";
448 }
449 
450 /**
451  * @tc.name: RegisterListener001
452  * @tc.desc: test RegisterListener
453  * @tc.type: FUNC
454  */
455 HWTEST_F(ImageSourceTest, RegisterListener001, TestSize.Level3)
456 {
457     GTEST_LOG_(INFO) << "ImageSourceTest: RegisterListener001 start";
458 
459     PeerListener *listener = nullptr;
460     uint32_t errorCode = 0;
461     SourceOptions opts;
462     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(IMAGE_INPUT_JPEG_PATH, opts, errorCode);
463     imageSource->RegisterListener(listener);
464 
465     GTEST_LOG_(INFO) << "ImageSourceTest: RegisterListener001 end";
466 }
467 
468 /**
469  * @tc.name: UnRegisterListener001
470  * @tc.desc: test UnRegisterListener
471  * @tc.type: FUNC
472  */
473 HWTEST_F(ImageSourceTest, UnRegisterListener001, TestSize.Level3)
474 {
475     GTEST_LOG_(INFO) << "ImageSourceTest: UnRegisterListener001 start";
476 
477     PeerListener *listener = nullptr;
478     uint32_t errorCode = 0;
479     SourceOptions opts;
480     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(IMAGE_INPUT_JPEG_PATH, opts, errorCode);
481     imageSource->UnRegisterListener(listener);
482 
483     GTEST_LOG_(INFO) << "ImageSourceTest: UnRegisterListener001 end";
484 }
485 
486 /**
487  * @tc.name: GetDecodeEvent001
488  * @tc.desc: test GetDecodeEvent
489  * @tc.type: FUNC
490  */
491 HWTEST_F(ImageSourceTest, GetDecodeEvent001, TestSize.Level3)
492 {
493     GTEST_LOG_(INFO) << "ImageSourceTest: GetDecodeEvent001 start";
494 
495     size_t bufferSize = 0;
496     bool ret = ImageUtils::GetFileSize(IMAGE_INPUT_JPEG_PATH, bufferSize);
497     ASSERT_EQ(ret, true);
498     uint8_t *buffer = reinterpret_cast<uint8_t *>(malloc(bufferSize));
499     ASSERT_NE(buffer, nullptr);
500     ret = OHOS::ImageSourceUtil::ReadFileToBuffer(IMAGE_INPUT_JPEG_PATH, buffer, bufferSize);
501     ASSERT_EQ(ret, true);
502     uint32_t errorCode = 0;
503     SourceOptions opts;
504     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(buffer, bufferSize, opts, errorCode);
505     ASSERT_EQ(errorCode, SUCCESS);
506     ASSERT_NE(imageSource.get(), nullptr);
507     GTEST_LOG_(INFO) << "ImageSourceTest: GetDecodeEvent111 start";
508     imageSource->GetDecodeEvent();
509 
510     GTEST_LOG_(INFO) << "ImageSourceTest: GetDecodeEvent001 end";
511 }
512 
513 /**
514  * @tc.name: AddDecodeListener001
515  * @tc.desc: test AddDecodeListener
516  * @tc.type: FUNC
517  */
518 HWTEST_F(ImageSourceTest, AddDecodeListener001, TestSize.Level3)
519 {
520     GTEST_LOG_(INFO) << "ImageSourceTest: AddDecodeListener001 start";
521 
522     DecodeListener *listener = nullptr;
523     uint32_t errorCode = 0;
524     SourceOptions opts;
525     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(IMAGE_INPUT_JPEG_PATH, opts, errorCode);
526     imageSource->AddDecodeListener(listener);
527 
528     GTEST_LOG_(INFO) << "ImageSourceTest: AddDecodeListener001 end";
529 }
530 
531 /**
532  * @tc.name: RemoveDecodeListener001
533  * @tc.desc: test RemoveDecodeListener
534  * @tc.type: FUNC
535  */
536 HWTEST_F(ImageSourceTest, RemoveDecodeListener001, TestSize.Level3)
537 {
538     GTEST_LOG_(INFO) << "ImageSourceTest: RemoveDecodeListener001 start";
539 
540     DecodeListener *listener = nullptr;
541     uint32_t errorCode = 0;
542     SourceOptions opts;
543     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(IMAGE_INPUT_JPEG_PATH, opts, errorCode);
544     imageSource->RemoveDecodeListener(listener);
545 
546     GTEST_LOG_(INFO) << "ImageSourceTest: RemoveDecodeListener001 end";
547 }
548 
549 /**
550  * @tc.name: IsIncrementalSource001
551  * @tc.desc: test IsIncrementalSource
552  * @tc.type: FUNC
553  */
554 HWTEST_F(ImageSourceTest, IsIncrementalSource001, TestSize.Level3)
555 {
556     GTEST_LOG_(INFO) << "ImageSourceTest: IsIncrementalSource001 start";
557 
558     bool isIncrementalSource_ = false;
559     uint32_t errorCode = 0;
560     SourceOptions opts;
561     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(IMAGE_INPUT_JPEG_PATH, opts, errorCode);
562     isIncrementalSource_ = imageSource->IsIncrementalSource();
563 
564     GTEST_LOG_(INFO) << "ImageSourceTest: IsIncrementalSource001 end";
565 }
566 
567 /**
568  * @tc.name: GetImagePropertyInt001
569  * @tc.desc: test GetImagePropertyInt
570  * @tc.type: FUNC
571  */
572 HWTEST_F(ImageSourceTest, GetImagePropertyInt001, TestSize.Level3)
573 {
574     GTEST_LOG_(INFO) << "ImageSourceTest: GetImagePropertyInt001 start";
575 
576     uint32_t errorCode = 0;
577     SourceOptions opts;
578     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(IMAGE_INPUT_JPEG_PATH, opts, errorCode);
579 
580     uint32_t index = 0;
581     int32_t value = 0;
582     std::string key;
583     imageSource->GetImagePropertyInt(index, key, value);
584 
585     GTEST_LOG_(INFO) << "ImageSourceTest: GetImagePropertyInt001 end";
586 }
587 
588 /**
589  * @tc.name: GetImagePropertyInt002
590  * @tc.desc: test GetImagePropertyInt
591  * @tc.type: FUNC
592  */
593 HWTEST_F(ImageSourceTest, GetImagePropertyInt002, TestSize.Level3)
594 {
595     GTEST_LOG_(INFO) << "ImageSourceTest: GetImagePropertyInt002 start";
596     uint32_t errorCode = 0;
597     SourceOptions opts;
598     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(IMAGE_INPUT_JPEG_PATH, opts, errorCode);
599     uint32_t index = 0;
600     int32_t value = 0;
601     std::string key;
602     imageSource->GetImagePropertyInt(index, key, value);
603     GTEST_LOG_(INFO) << "ImageSourceTest: GetImagePropertyInt002 end";
604 }
605 
606 /**
607  * @tc.name: GetImagePropertyString001
608  * @tc.desc: test GetImagePropertyString
609  * @tc.type: FUNC
610  */
611 HWTEST_F(ImageSourceTest, GetImagePropertyString001, TestSize.Level3)
612 {
613     GTEST_LOG_(INFO) << "ImageSourceTest: GetImagePropertyString001 start";
614     uint32_t errorCode = 0;
615     SourceOptions opts;
616     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(IMAGE_INPUT_JPEG_PATH, opts, errorCode);
617 
618     uint32_t index = 0;
619     std::string key = "";
620     std::string value;
621     uint32_t ret = imageSource->GetImagePropertyString(index, key, value);
622     ASSERT_NE(ret, 0);
623     GTEST_LOG_(INFO) << "ImageSourceTest: GetImagePropertyString001 end";
624 }
625 
626 /**
627  * @tc.name: GetImagePropertyString002
628  * @tc.desc: test GetImagePropertyString
629  * @tc.type: FUNC
630  */
631 HWTEST_F(ImageSourceTest, GetImagePropertyString002, TestSize.Level3)
632 {
633     GTEST_LOG_(INFO) << "ImageSourceTest: GetImagePropertyString002 start";
634     uint32_t errorCode = 0;
635     SourceOptions opts;
636     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(IMAGE_INPUT_JPEG_PATH, opts, errorCode);
637 
638     uint32_t index = 0;
639     std::string key = "";
640     std::string value;
641     imageSource->GetImagePropertyString(index, key, value);
642     GTEST_LOG_(INFO) << "ImageSourceTest: GetImagePropertyString002 end";
643 }
644 
645 /**
646  * @tc.name: ModifyImageProperty001
647  * @tc.desc: test ModifyImageProperty(index, key, value, path)
648  * @tc.type: FUNC
649  */
650 HWTEST_F(ImageSourceTest, ModifyImageProperty001, TestSize.Level3)
651 {
652     GTEST_LOG_(INFO) << "ImageSourceTest: ModifyImageProperty001 start";
653     uint32_t errorCode = 0;
654     SourceOptions opts;
655     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(IMAGE_INPUT_JPEG_PATH, opts, errorCode);
656 
657     uint32_t index = 0;
658     std::string value = "";
659     std::string key = "";
660     std::string path = "";
661     uint32_t ret = imageSource->ModifyImageProperty(index, key, value, path);
662     ASSERT_NE(ret, 0);
663     GTEST_LOG_(INFO) << "ImageSourceTest: ModifyImageProperty001 end";
664 }
665 
666 /**
667  * @tc.name: ModifyImageProperty002
668  * @tc.desc: test ModifyImageProperty(index, key, value, fd)
669  * @tc.type: FUNC
670  */
671 HWTEST_F(ImageSourceTest, ModifyImageProperty002, TestSize.Level3)
672 {
673     GTEST_LOG_(INFO) << "ImageSourceTest: ModifyImageProperty002 start";
674 
675 
676     uint32_t errorCode = 0;
677     SourceOptions opts;
678     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(IMAGE_INPUT_JPEG_PATH, opts, errorCode);
679     uint32_t index = 0;
680     std::string value;
681     std::string key;
682     int fd = open("/data/receiver/Receiver_buffer7.jpg", std::fstream::binary | std::fstream::in);
683     uint32_t ret = imageSource->ModifyImageProperty(index, key, value, fd);
684     ASSERT_NE(ret, 0);
685 
686     GTEST_LOG_(INFO) << "ImageSourceTest: ModifyImageProperty002 end";
687 }
688 
689 /**
690  * @tc.name: ModifyImageProperty003
691  * @tc.desc: test ModifyImageProperty(index, key, value, data, size)
692  * @tc.type: FUNC
693  */
694 HWTEST_F(ImageSourceTest, ModifyImageProperty003, TestSize.Level3)
695 {
696     GTEST_LOG_(INFO) << "ImageSourceTest: ModifyImageProperty003 start";
697     uint32_t errorCode = 0;
698     SourceOptions opts;
699     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(IMAGE_INPUT_JPEG_PATH, opts, errorCode);
700 
701     uint32_t index = 0;
702     std::string value;
703     uint8_t *data = nullptr;
704     uint32_t size = 0;
705 
706     std::string key;
707     uint32_t ret = imageSource->ModifyImageProperty(index, key, value, data, size);
708     ASSERT_NE(ret, 0);
709 
710     GTEST_LOG_(INFO) << "ImageSourceTest: ModifyImageProperty003 end";
711 }
712 
713 /**
714  * @tc.name: GetNinePatchInfo001
715  * @tc.desc: test GetNinePatchInfo
716  * @tc.type: FUNC
717  */
718 HWTEST_F(ImageSourceTest, GetNinePatchInfo001, TestSize.Level3)
719 {
720     GTEST_LOG_(INFO) << "ImageSourceTest: GetNinePatchInfo001 start";
721 
722     std::unique_ptr<std::fstream> fs = std::make_unique<std::fstream>();
723     fs->open("/data/local/tmp/image/test.jpg", std::fstream::binary | std::fstream::in);
724     bool isOpen = fs->is_open();
725     ASSERT_EQ(isOpen, true);
726     uint32_t errorCode = 0;
727     SourceOptions opts;
728     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(std::move(fs), opts, errorCode);
729 
730     const NinePatchInfo &ninePatch = imageSource->GetNinePatchInfo();
731     ASSERT_EQ(ninePatch.ninePatch, nullptr);
732 
733     GTEST_LOG_(INFO) << "ImageSourceTest: GetNinePatchInfo001 end";
734 }
735 
736 /**
737  * @tc.name: SetMemoryUsagePreference001
738  * @tc.desc: test SetMemoryUsagePreference
739  * @tc.type: FUNC
740  */
741 HWTEST_F(ImageSourceTest, SetMemoryUsagePreference001, TestSize.Level3)
742 {
743     GTEST_LOG_(INFO) << "ImageSourceTest: SetMemoryUsagePreference001 start";
744 
745     std::unique_ptr<std::fstream> fs = std::make_unique<std::fstream>();
746     fs->open("/data/local/tmp/image/test.jpg", std::fstream::binary | std::fstream::in);
747     bool isOpen = fs->is_open();
748     ASSERT_EQ(isOpen, true);
749     uint32_t errorCode = 0;
750     SourceOptions opts;
751     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(std::move(fs), opts, errorCode);
752     MemoryUsagePreference preference = MemoryUsagePreference::LOW_RAM;
753     imageSource->SetMemoryUsagePreference(preference);
754 
755     GTEST_LOG_(INFO) << "ImageSourceTest: SetMemoryUsagePreference001 end";
756 }
757 
758 /**
759  * @tc.name: GetMemoryUsagePreference001
760  * @tc.desc: test GetMemoryUsagePreference
761  * @tc.type: FUNC
762  */
763 HWTEST_F(ImageSourceTest, GetMemoryUsagePreference001, TestSize.Level3)
764 {
765     GTEST_LOG_(INFO) << "ImageSourceTest: GetMemoryUsagePreference001 start";
766 
767     std::unique_ptr<std::fstream> fs = std::make_unique<std::fstream>();
768     fs->open("/data/local/tmp/image/test.jpg", std::fstream::binary | std::fstream::in);
769     bool isOpen = fs->is_open();
770     ASSERT_EQ(isOpen, true);
771     uint32_t errorCode = 0;
772     SourceOptions opts;
773     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(std::move(fs), opts, errorCode);
774     imageSource->GetMemoryUsagePreference();
775 
776     GTEST_LOG_(INFO) << "ImageSourceTest: GetMemoryUsagePreference001 end";
777 }
778 
779 /**
780  * @tc.name: GetFilterArea001
781  * @tc.desc: test GetFilterArea(filterType, ranges)
782  * @tc.type: FUNC
783  */
784 HWTEST_F(ImageSourceTest, GetFilterArea001, TestSize.Level3)
785 {
786     GTEST_LOG_(INFO) << "ImageSourceTest: GetFilterArea001 start";
787 
788     int filterType = 0;
789     std::unique_ptr<std::fstream> fs = std::make_unique<std::fstream>();
790     fs->open("/data/local/tmp/image/test.jpg", std::fstream::binary | std::fstream::in);
791     bool isOpen = fs->is_open();
792     ASSERT_EQ(isOpen, true);
793     uint32_t errorCode = 0;
794     SourceOptions opts;
795     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(std::move(fs), opts, errorCode);
796     std::vector<std::pair<uint32_t, uint32_t>> ranges;
797     uint32_t ret = imageSource->GetFilterArea(filterType, ranges);
798     ASSERT_NE(ret, 0);
799 
800     GTEST_LOG_(INFO) << "ImageSourceTest: GetFilterArea001 end";
801 }
802 
803 /**
804  * @tc.name: CreateImageSource001
805  * @tc.desc: test CreateImageSource is
806  * @tc.type: FUNC
807  */
808 HWTEST_F(ImageSourceTest, CreateImageSource001, TestSize.Level3)
809 {
810     GTEST_LOG_(INFO) << "ImageSourceTest: CreateImageSource001 start";
811 
812     std::unique_ptr<std::fstream> fs = std::make_unique<std::fstream>();
813     uint32_t errorCode = 0;
814     SourceOptions opts;
815     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(std::move(fs), opts, errorCode);
816     ASSERT_NE(imageSource, nullptr);
817 
818     GTEST_LOG_(INFO) << "ImageSourceTest: CreateImageSource001 end";
819 }
820 
821 /**
822  * @tc.name: CreateImageSource002
823  * @tc.desc: test CreateImageSource
824  * @tc.type: FUNC
825  */
826 HWTEST_F(ImageSourceTest, CreateImageSource002, TestSize.Level3)
827 {
828     GTEST_LOG_(INFO) << "ImageSourceTest: CreateImageSource002 start";
829 
830     std::unique_ptr<std::fstream> fs = std::make_unique<std::fstream>();
831     fs->open("/data/local/tmp/image/test.jpg", std::fstream::binary | std::fstream::in);
832     bool isOpen = fs->is_open();
833     ASSERT_EQ(isOpen, true);
834     uint32_t errorCode = 0;
835     SourceOptions opts;
836     opts.size.width = -1;
837     opts.size.height = -1;
838     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(std::move(fs), opts, errorCode);
839     ASSERT_NE(imageSource, nullptr);
840 
841     GTEST_LOG_(INFO) << "ImageSourceTest: CreateImageSource002 end";
842 }
843 
844 /**
845  * @tc.name: CreateImageSource009
846  * @tc.desc: test CreateImageSource buffer is nullptr
847  * @tc.type: FUNC
848  */
849 HWTEST_F(ImageSourceTest, CreateImageSource009, TestSize.Level3)
850 {
851     GTEST_LOG_(INFO) << "ImageSourceTest: CreateImageSource009 start";
852     size_t bufferSize = 0;
853     bool ret = ImageUtils::GetFileSize(IMAGE_INPUT_JPEG_PATH, bufferSize);
854     ASSERT_EQ(ret, true);
855     uint8_t *buffer = nullptr;
856 
857     uint32_t errorCode = 0;
858     SourceOptions opts;
859     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(buffer, bufferSize, opts, errorCode);
860     ASSERT_NE(errorCode, SUCCESS);
861     ASSERT_EQ(imageSource.get(), nullptr);
862     GTEST_LOG_(INFO) << "ImageSourceTest: CreateImageSource009 end";
863 }
864 
865 /**
866  * @tc.name: CreateImageSource0010
867  * @tc.desc: test CreateImageSource size is 0
868  * @tc.type: FUNC
869  */
870 HWTEST_F(ImageSourceTest, CreateImageSource0010, TestSize.Level3)
871 {
872     GTEST_LOG_(INFO) << "ImageSourceTest: CreateImageSource0010 start";
873     size_t bufferSize = 0;
874     bool ret = ImageUtils::GetFileSize(IMAGE_INPUT_JPEG_PATH, bufferSize);
875     ASSERT_EQ(ret, true);
876     uint8_t *buffer = reinterpret_cast<uint8_t *>(malloc(bufferSize));
877     ASSERT_NE(buffer, nullptr);
878 
879     uint32_t size = 0;
880     uint32_t errorCode = 0;
881     SourceOptions opts;
882     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(buffer, size, opts, errorCode);
883     ASSERT_NE(errorCode, SUCCESS);
884     ASSERT_EQ(imageSource.get(), nullptr);
885     GTEST_LOG_(INFO) << "ImageSourceTest: CreateImageSource0010 end";
886 }
887 
888 /**
889  * @tc.name: CreateImageSource0011
890  * @tc.desc: test CreateImageSource size is 0 and buffer is nullptr
891  * @tc.type: FUNC
892  */
893 HWTEST_F(ImageSourceTest, CreateImageSource0011, TestSize.Level3)
894 {
895     GTEST_LOG_(INFO) << "ImageSourceTest: CreateImageSource0011 start";
896     uint8_t *buffer = nullptr;
897 
898     uint32_t size = 0;
899     uint32_t errorCode = 0;
900     SourceOptions opts;
901     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(buffer, size, opts, errorCode);
902     ASSERT_NE(errorCode, SUCCESS);
903     ASSERT_EQ(imageSource.get(), nullptr);
904     GTEST_LOG_(INFO) << "ImageSourceTest: CreateImageSource0011 end";
905 }
906 } // namespace Multimedia
907 } // namespace OHOS