• 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     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     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     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 
207     GTEST_LOG_(INFO) << "ImageSourceTest: CreateImageSource008 end";
208 }
209 
210 /**
211  * @tc.name: CreateIncrementalImageSource001
212  * @tc.desc: test CreateIncrementalImageSource
213  * @tc.type: FUNC
214  */
215 HWTEST_F(ImageSourceTest, CreateIncrementalImageSource001, TestSize.Level3)
216 {
217     GTEST_LOG_(INFO) << "ImageSourceTest: CreateIncrementalImageSource001 start";
218     uint32_t errorCode = 0;
219     const IncrementalSourceOptions opts;
220     std::unique_ptr<ImageSource> img = ImageSource::CreateIncrementalImageSource(opts, errorCode);
221     ASSERT_NE(img, nullptr);
222     GTEST_LOG_(INFO) << "ImageSourceTest: CreateIncrementalImageSource001 end";
223 }
224 
225 /**
226  * @tc.name: CreatePixelMapEx001
227  * @tc.desc: test CreatePixelMapEx
228  * @tc.type: FUNC
229  */
230 HWTEST_F(ImageSourceTest, CreatePixelMapEx001, TestSize.Level3)
231 {
232     GTEST_LOG_(INFO) << "ImageSourceTest: CreatePixelMapEx001 start";
233     uint32_t errorCode = 0;
234     IncrementalSourceOptions incOpts;
235     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateIncrementalImageSource(incOpts, errorCode);
236     uint32_t index = 1;
237     const DecodeOptions opts;
238     std::unique_ptr<PixelMap> crepixelmapex = imageSource->CreatePixelMapEx(index, opts, errorCode);
239     ASSERT_EQ(crepixelmapex, nullptr);
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     uint32_t errorCode = 0;
252     SourceOptions opts;
253     opts.formatHint = "image/jpeg";
254     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(IMAGE_INPUT_JPEG_PATH, opts, errorCode);
255     uint32_t index = 1;
256     const DecodeOptions opt;
257     imageSource->CreatePixelMapEx(index, opt, errorCode);
258     GTEST_LOG_(INFO) << "ImageSourceTest: CreatePixelMapEx002 end";
259 }
260 
261 /**
262  * @tc.name: CreatePixelMap001
263  * @tc.desc: test CreatePixelMap
264  * @tc.type: FUNC
265  */
266 HWTEST_F(ImageSourceTest, CreatePixelMap001, TestSize.Level3)
267 {
268     GTEST_LOG_(INFO) << "ImageSourceTest: CreatePixelMap001 start";
269     uint32_t errorCode = 0;
270     IncrementalSourceOptions incOpts;
271     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateIncrementalImageSource(incOpts, errorCode);
272     uint32_t index = 1;
273     const DecodeOptions opts;
274     std::unique_ptr<PixelMap> crepixelmap = imageSource->CreatePixelMap(index, opts, errorCode);
275     ASSERT_EQ(crepixelmap, nullptr);
276     GTEST_LOG_(INFO) << "ImageSourceTest: CreatePixelMap001 end";
277 }
278 
279 /**
280  * @tc.name: CreatePixelMap002
281  * @tc.desc: test CreatePixelMap
282  * @tc.type: FUNC
283  */
284 HWTEST_F(ImageSourceTest, CreatePixelMap002, TestSize.Level3)
285 {
286     GTEST_LOG_(INFO) << "ImageSourceTest: CreatePixelMap002 start";
287 
288     uint32_t errorCode = 0;
289     IncrementalSourceOptions incOpts;
290     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateIncrementalImageSource(incOpts, errorCode);
291     uint32_t index = 1;
292     const DecodeOptions opts;
293     std::unique_ptr<PixelMap> crepixelmap = imageSource->CreatePixelMap(index, opts, errorCode);
294     ASSERT_EQ(crepixelmap, nullptr);
295 
296     GTEST_LOG_(INFO) << "ImageSourceTest: CreatePixelMap002 end";
297 }
298 
299 /**
300  * @tc.name: CreateIncrementalPixelMap001
301  * @tc.desc: test CreateIncrementalPixelMap
302  * @tc.type: FUNC
303  */
304 HWTEST_F(ImageSourceTest, CreateIncrementalPixelMap001, TestSize.Level3)
305 {
306     GTEST_LOG_(INFO) << "ImageSourceTest: CreateIncrementalPixelMap001 start";
307 
308     size_t bufferSize = 0;
309     bool fileRet = ImageUtils::GetFileSize(IMAGE_INPUT_JPEG_PATH, bufferSize);
310     ASSERT_EQ(fileRet, true);
311     uint8_t *buffer = reinterpret_cast<uint8_t *>(malloc(bufferSize));
312     ASSERT_NE(buffer, nullptr);
313     fileRet = OHOS::ImageSourceUtil::ReadFileToBuffer(IMAGE_INPUT_JPEG_PATH, buffer, bufferSize);
314     ASSERT_EQ(fileRet, true);
315     uint32_t errorCode = 0;
316     IncrementalSourceOptions incOpts;
317     incOpts.incrementalMode = IncrementalMode::INCREMENTAL_DATA;
318     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateIncrementalImageSource(incOpts, errorCode);
319     ASSERT_EQ(errorCode, SUCCESS);
320 
321     DecodeOptions decodeOpts;
322     std::unique_ptr<IncrementalPixelMap> incPixelMap = imageSource->CreateIncrementalPixelMap(0, decodeOpts,
323         errorCode);
324     ASSERT_NE(incPixelMap, nullptr);
325 
326     GTEST_LOG_(INFO) << "ImageSourceTest: CreateIncrementalPixelMap001 end";
327 }
328 
329 /**
330  * @tc.name: CreateIncrementalPixelMap002
331  * @tc.desc: test CreateIncrementalPixelMap
332  * @tc.type: FUNC
333  */
334 HWTEST_F(ImageSourceTest, CreateIncrementalPixelMap002, TestSize.Level3)
335 {
336     GTEST_LOG_(INFO) << "ImageSourceTest: CreateIncrementalPixelMap002 start";
337 
338     uint32_t errorCode = 0;
339     SourceOptions opts;
340     opts.formatHint = "image/jpeg";
341     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(IMAGE_INPUT_JPEG_PATH, opts, errorCode);
342 
343     uint32_t info = 100;
344     DecodeOptions op;
345     op.sampleSize = 1;
346     imageSource->CreatePixelMap(info, op, errorCode);
347     info = -1;
348     op.sampleSize = 0;
349     imageSource->CreatePixelMap(info, op, errorCode);
350 
351     GTEST_LOG_(INFO) << "ImageSourceTest: CreateIncrementalPixelMap002 end";
352 }
353 
354 /**
355  * @tc.name: UpdateData001
356  * @tc.desc: test UpdateData
357  * @tc.type: FUNC
358  */
359 HWTEST_F(ImageSourceTest, UpdateData001, TestSize.Level3)
360 {
361     GTEST_LOG_(INFO) << "ImageSourceTest: UpdateData001 start";
362     uint32_t errorCode = 0;
363     SourceOptions opts;
364     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(IMAGE_INPUT_JPEG_PATH, opts, errorCode);
365 
366     DecodeOptions decodeOpts;
367     size_t bufferSize = 0;
368     uint8_t *buffer = reinterpret_cast<uint8_t *>(malloc(bufferSize));
369     std::unique_ptr<IncrementalPixelMap> incPixelMap = imageSource->CreateIncrementalPixelMap(0, decodeOpts,
370         errorCode);
371     ASSERT_NE(incPixelMap, nullptr);
372     uint32_t updateSize = 0;
373     srand(time(nullptr));
374     bool isCompleted = false;
375     while (updateSize < bufferSize) {
376         uint32_t updateOnceSize = rand() % 1024;
377         if (updateSize + updateOnceSize > bufferSize) {
378             updateOnceSize = bufferSize - updateSize;
379             isCompleted = true;
380         }
381         uint32_t ret = imageSource->UpdateData(buffer + updateSize, updateOnceSize, isCompleted);
382         ASSERT_EQ(ret, SUCCESS);
383         uint8_t decodeProgress = 0;
384         incPixelMap->PromoteDecoding(decodeProgress);
385         updateSize += updateOnceSize;
386     }
387     GTEST_LOG_(INFO) << "ImageSourceTest: UpdateData001 end";
388 }
389 
390  /**
391   * @tc.name: GetImageInfo001
392   * @tc.desc: test GetImageInfo
393   * @tc.type: FUNC
394   */
395 HWTEST_F(ImageSourceTest, GetImageInfo001, TestSize.Level3)
396 {
397     GTEST_LOG_(INFO) << "ImageSourceTest: GetImageInfo001 start";
398 
399     uint32_t errorCode = 0;
400     SourceOptions opts;
401     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(IMAGE_INPUT_JPEG_PATH, opts, errorCode);
402 
403     ImageInfo imageInfo;
404     uint32_t index = 1;
405     uint32_t ret = imageSource->GetImageInfo(index, imageInfo);
406     ASSERT_EQ(ret, ERR_IMAGE_DECODE_FAILED);
407     GTEST_LOG_(INFO) << "ImageSourceTest: GetImageInfo001 end";
408 }
409 
410  /**
411   * @tc.name: GetImageInfo002
412   * @tc.desc: test GetImageInfo
413   * @tc.type: FUNC
414   */
415 HWTEST_F(ImageSourceTest, GetImageInfo002, TestSize.Level3)
416 {
417     GTEST_LOG_(INFO) << "ImageSourceTest: GetImageInfo002 start";
418 
419     uint32_t errorCode = 0;
420     SourceOptions opts;
421     opts.formatHint = "image/jpeg";
422     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(IMAGE_INPUT_JPEG_PATH, opts, errorCode);
423 
424     ImageInfo imageInfo;
425     uint32_t index = 1;
426     imageSource->GetImageInfo(index, imageInfo);
427     GTEST_LOG_(INFO) << "ImageSourceTest: GetImageInfo002 end";
428 }
429 
430 /**
431  * @tc.name: GetSourceInfo001
432  * @tc.desc: test GetSourceInfo
433  * @tc.type: FUNC
434  */
435 HWTEST_F(ImageSourceTest, GetSourceInfo001, TestSize.Level3)
436 {
437     GTEST_LOG_(INFO) << "ImageSourceTest: GetSourceInfo001 start";
438 
439     uint32_t errorCode = 0;
440     SourceOptions opts;
441     opts.formatHint = "image/jpeg";
442     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(IMAGE_INPUT_JPEG_PATH, opts, errorCode);
443 
444     SourceInfo sourceInfo = imageSource->GetSourceInfo(errorCode);
445 
446     GTEST_LOG_(INFO) << "ImageSourceTest: GetSourceInfo001 end";
447 }
448 
449 /**
450  * @tc.name: RegisterListener001
451  * @tc.desc: test RegisterListener
452  * @tc.type: FUNC
453  */
454 HWTEST_F(ImageSourceTest, RegisterListener001, TestSize.Level3)
455 {
456     GTEST_LOG_(INFO) << "ImageSourceTest: RegisterListener001 start";
457 
458     PeerListener *listener = nullptr;
459     uint32_t errorCode = 0;
460     SourceOptions opts;
461     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(IMAGE_INPUT_JPEG_PATH, opts, errorCode);
462     imageSource->RegisterListener(listener);
463 
464     GTEST_LOG_(INFO) << "ImageSourceTest: RegisterListener001 end";
465 }
466 
467 /**
468  * @tc.name: UnRegisterListener001
469  * @tc.desc: test UnRegisterListener
470  * @tc.type: FUNC
471  */
472 HWTEST_F(ImageSourceTest, UnRegisterListener001, TestSize.Level3)
473 {
474     GTEST_LOG_(INFO) << "ImageSourceTest: UnRegisterListener001 start";
475 
476     PeerListener *listener = nullptr;
477     uint32_t errorCode = 0;
478     SourceOptions opts;
479     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(IMAGE_INPUT_JPEG_PATH, opts, errorCode);
480     imageSource->UnRegisterListener(listener);
481 
482     GTEST_LOG_(INFO) << "ImageSourceTest: UnRegisterListener001 end";
483 }
484 
485 /**
486  * @tc.name: GetDecodeEvent001
487  * @tc.desc: test GetDecodeEvent
488  * @tc.type: FUNC
489  */
490 HWTEST_F(ImageSourceTest, GetDecodeEvent001, TestSize.Level3)
491 {
492     GTEST_LOG_(INFO) << "ImageSourceTest: GetDecodeEvent001 start";
493 
494     size_t bufferSize = 0;
495     bool ret = ImageUtils::GetFileSize(IMAGE_INPUT_JPEG_PATH, bufferSize);
496     ASSERT_EQ(ret, true);
497     uint8_t *buffer = reinterpret_cast<uint8_t *>(malloc(bufferSize));
498     ASSERT_NE(buffer, nullptr);
499     ret = OHOS::ImageSourceUtil::ReadFileToBuffer(IMAGE_INPUT_JPEG_PATH, buffer, bufferSize);
500     ASSERT_EQ(ret, true);
501     uint32_t errorCode = 0;
502     SourceOptions opts;
503     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(buffer, bufferSize, opts, errorCode);
504     ASSERT_EQ(errorCode, SUCCESS);
505     ASSERT_NE(imageSource.get(), nullptr);
506     GTEST_LOG_(INFO) << "ImageSourceTest: GetDecodeEvent111 start";
507     imageSource->GetDecodeEvent();
508 
509     GTEST_LOG_(INFO) << "ImageSourceTest: GetDecodeEvent001 end";
510 }
511 
512 /**
513  * @tc.name: AddDecodeListener001
514  * @tc.desc: test AddDecodeListener
515  * @tc.type: FUNC
516  */
517 HWTEST_F(ImageSourceTest, AddDecodeListener001, TestSize.Level3)
518 {
519     GTEST_LOG_(INFO) << "ImageSourceTest: AddDecodeListener001 start";
520 
521     DecodeListener *listener = nullptr;
522     uint32_t errorCode = 0;
523     SourceOptions opts;
524     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(IMAGE_INPUT_JPEG_PATH, opts, errorCode);
525     imageSource->AddDecodeListener(listener);
526 
527     GTEST_LOG_(INFO) << "ImageSourceTest: AddDecodeListener001 end";
528 }
529 
530 /**
531  * @tc.name: RemoveDecodeListener001
532  * @tc.desc: test RemoveDecodeListener
533  * @tc.type: FUNC
534  */
535 HWTEST_F(ImageSourceTest, RemoveDecodeListener001, TestSize.Level3)
536 {
537     GTEST_LOG_(INFO) << "ImageSourceTest: RemoveDecodeListener001 start";
538 
539     DecodeListener *listener = nullptr;
540     uint32_t errorCode = 0;
541     SourceOptions opts;
542     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(IMAGE_INPUT_JPEG_PATH, opts, errorCode);
543     imageSource->RemoveDecodeListener(listener);
544 
545     GTEST_LOG_(INFO) << "ImageSourceTest: RemoveDecodeListener001 end";
546 }
547 
548 /**
549  * @tc.name: IsIncrementalSource001
550  * @tc.desc: test IsIncrementalSource
551  * @tc.type: FUNC
552  */
553 HWTEST_F(ImageSourceTest, IsIncrementalSource001, TestSize.Level3)
554 {
555     GTEST_LOG_(INFO) << "ImageSourceTest: IsIncrementalSource001 start";
556 
557     bool isIncrementalSource_ = false;
558     uint32_t errorCode = 0;
559     SourceOptions opts;
560     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(IMAGE_INPUT_JPEG_PATH, opts, errorCode);
561     isIncrementalSource_ = imageSource->IsIncrementalSource();
562 
563     GTEST_LOG_(INFO) << "ImageSourceTest: IsIncrementalSource001 end";
564 }
565 
566 /**
567  * @tc.name: GetImagePropertyInt001
568  * @tc.desc: test GetImagePropertyInt
569  * @tc.type: FUNC
570  */
571 HWTEST_F(ImageSourceTest, GetImagePropertyInt001, TestSize.Level3)
572 {
573     GTEST_LOG_(INFO) << "ImageSourceTest: GetImagePropertyInt001 start";
574 
575     uint32_t errorCode = 0;
576     SourceOptions opts;
577     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(IMAGE_INPUT_JPEG_PATH, opts, errorCode);
578 
579     uint32_t index = 0;
580     int32_t value = 0;
581     std::string key;
582     imageSource->GetImagePropertyInt(index, key, value);
583 
584     GTEST_LOG_(INFO) << "ImageSourceTest: GetImagePropertyInt001 end";
585 }
586 
587 /**
588  * @tc.name: GetImagePropertyInt002
589  * @tc.desc: test GetImagePropertyInt
590  * @tc.type: FUNC
591  */
592 HWTEST_F(ImageSourceTest, GetImagePropertyInt002, TestSize.Level3)
593 {
594     GTEST_LOG_(INFO) << "ImageSourceTest: GetImagePropertyInt002 start";
595     uint32_t errorCode = 0;
596     SourceOptions opts;
597     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(IMAGE_INPUT_JPEG_PATH, opts, errorCode);
598     uint32_t index = 0;
599     int32_t value = 0;
600     std::string key;
601     imageSource->GetImagePropertyInt(index, key, value);
602     GTEST_LOG_(INFO) << "ImageSourceTest: GetImagePropertyInt002 end";
603 }
604 
605 /**
606  * @tc.name: GetImagePropertyString001
607  * @tc.desc: test GetImagePropertyString
608  * @tc.type: FUNC
609  */
610 HWTEST_F(ImageSourceTest, GetImagePropertyString001, TestSize.Level3)
611 {
612     GTEST_LOG_(INFO) << "ImageSourceTest: GetImagePropertyString001 start";
613 
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 
635     uint32_t errorCode = 0;
636     SourceOptions opts;
637     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(IMAGE_INPUT_JPEG_PATH, opts, errorCode);
638 
639     uint32_t index = 0;
640     std::string key = "";
641     std::string value;
642     imageSource->GetImagePropertyString(index, key, value);
643 
644     GTEST_LOG_(INFO) << "ImageSourceTest: GetImagePropertyString002 end";
645 }
646 
647 /**
648  * @tc.name: ModifyImageProperty001
649  * @tc.desc: test ModifyImageProperty(index, key, value, path)
650  * @tc.type: FUNC
651  */
652 HWTEST_F(ImageSourceTest, ModifyImageProperty001, TestSize.Level3)
653 {
654     GTEST_LOG_(INFO) << "ImageSourceTest: ModifyImageProperty001 start";
655     uint32_t errorCode = 0;
656     SourceOptions opts;
657     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(IMAGE_INPUT_JPEG_PATH, opts, errorCode);
658 
659     uint32_t index = 0;
660     std::string value = "";
661     std::string key = "";
662     std::string path = "";
663     uint32_t ret = imageSource->ModifyImageProperty(index, key, value, path);
664     ASSERT_NE(ret, 0);
665     GTEST_LOG_(INFO) << "ImageSourceTest: ModifyImageProperty001 end";
666 }
667 
668 /**
669  * @tc.name: ModifyImageProperty002
670  * @tc.desc: test ModifyImageProperty(index, key, value, fd)
671  * @tc.type: FUNC
672  */
673 HWTEST_F(ImageSourceTest, ModifyImageProperty002, TestSize.Level3)
674 {
675     GTEST_LOG_(INFO) << "ImageSourceTest: ModifyImageProperty002 start";
676 
677 
678     uint32_t errorCode = 0;
679     SourceOptions opts;
680     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(IMAGE_INPUT_JPEG_PATH, opts, errorCode);
681 
682     uint32_t index = 0;
683     std::string value;
684     std::string key;
685     int fd = open("/data/receiver/Receiver_buffer7.jpg", std::fstream::binary | std::fstream::in);
686     uint32_t ret = imageSource->ModifyImageProperty(index, key, value, fd);
687     ASSERT_NE(ret, 0);
688 
689     GTEST_LOG_(INFO) << "ImageSourceTest: ModifyImageProperty002 end";
690 }
691 
692 /**
693  * @tc.name: ModifyImageProperty003
694  * @tc.desc: test ModifyImageProperty(index, key, value, data, size)
695  * @tc.type: FUNC
696  */
697 HWTEST_F(ImageSourceTest, ModifyImageProperty003, TestSize.Level3)
698 {
699     GTEST_LOG_(INFO) << "ImageSourceTest: ModifyImageProperty003 start";
700     uint32_t errorCode = 0;
701     SourceOptions opts;
702     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(IMAGE_INPUT_JPEG_PATH, opts, errorCode);
703 
704     uint32_t index = 0;
705     std::string value;
706     uint8_t *data = nullptr;
707     uint32_t size = 0;
708 
709     std::string key;
710     uint32_t ret = imageSource->ModifyImageProperty(index, key, value, data, size);
711     ASSERT_NE(ret, 0);
712 
713     GTEST_LOG_(INFO) << "ImageSourceTest: ModifyImageProperty003 end";
714 }
715 
716 /**
717  * @tc.name: GetNinePatchInfo001
718  * @tc.desc: test GetNinePatchInfo
719  * @tc.type: FUNC
720  */
721 HWTEST_F(ImageSourceTest, GetNinePatchInfo001, TestSize.Level3)
722 {
723     GTEST_LOG_(INFO) << "ImageSourceTest: GetNinePatchInfo001 start";
724 
725     std::unique_ptr<std::fstream> fs = std::make_unique<std::fstream>();
726     fs->open("/data/local/tmp/image/test.jpg", std::fstream::binary | std::fstream::in);
727     bool isOpen = fs->is_open();
728     ASSERT_EQ(isOpen, true);
729     uint32_t errorCode = 0;
730     SourceOptions opts;
731     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(std::move(fs), opts, errorCode);
732 
733     const NinePatchInfo &ninePatch = imageSource->GetNinePatchInfo();
734     ASSERT_EQ(ninePatch.ninePatch, nullptr);
735 
736     GTEST_LOG_(INFO) << "ImageSourceTest: GetNinePatchInfo001 end";
737 }
738 
739 /**
740  * @tc.name: SetMemoryUsagePreference001
741  * @tc.desc: test SetMemoryUsagePreference
742  * @tc.type: FUNC
743  */
744 HWTEST_F(ImageSourceTest, SetMemoryUsagePreference001, TestSize.Level3)
745 {
746     GTEST_LOG_(INFO) << "ImageSourceTest: SetMemoryUsagePreference001 start";
747 
748     std::unique_ptr<std::fstream> fs = std::make_unique<std::fstream>();
749     fs->open("/data/local/tmp/image/test.jpg", std::fstream::binary | std::fstream::in);
750     bool isOpen = fs->is_open();
751     ASSERT_EQ(isOpen, true);
752     uint32_t errorCode = 0;
753     SourceOptions opts;
754     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(std::move(fs), opts, errorCode);
755     MemoryUsagePreference preference = MemoryUsagePreference::LOW_RAM;
756     imageSource->SetMemoryUsagePreference(preference);
757 
758     GTEST_LOG_(INFO) << "ImageSourceTest: SetMemoryUsagePreference001 end";
759 }
760 
761 /**
762  * @tc.name: GetMemoryUsagePreference001
763  * @tc.desc: test GetMemoryUsagePreference
764  * @tc.type: FUNC
765  */
766 HWTEST_F(ImageSourceTest, GetMemoryUsagePreference001, TestSize.Level3)
767 {
768     GTEST_LOG_(INFO) << "ImageSourceTest: GetMemoryUsagePreference001 start";
769 
770     std::unique_ptr<std::fstream> fs = std::make_unique<std::fstream>();
771     fs->open("/data/local/tmp/image/test.jpg", std::fstream::binary | std::fstream::in);
772     bool isOpen = fs->is_open();
773     ASSERT_EQ(isOpen, true);
774     uint32_t errorCode = 0;
775     SourceOptions opts;
776     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(std::move(fs), opts, errorCode);
777     imageSource->GetMemoryUsagePreference();
778 
779     GTEST_LOG_(INFO) << "ImageSourceTest: GetMemoryUsagePreference001 end";
780 }
781 
782 /**
783  * @tc.name: GetFilterArea001
784  * @tc.desc: test GetFilterArea(filterType, ranges)
785  * @tc.type: FUNC
786  */
787 HWTEST_F(ImageSourceTest, GetFilterArea001, TestSize.Level3)
788 {
789     GTEST_LOG_(INFO) << "ImageSourceTest: GetFilterArea001 start";
790 
791     int filterType = 0;
792     std::unique_ptr<std::fstream> fs = std::make_unique<std::fstream>();
793     fs->open("/data/local/tmp/image/test.jpg", std::fstream::binary | std::fstream::in);
794     bool isOpen = fs->is_open();
795     ASSERT_EQ(isOpen, true);
796     uint32_t errorCode = 0;
797     SourceOptions opts;
798     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(std::move(fs), opts, errorCode);
799     std::vector<std::pair<uint32_t, uint32_t>> ranges;
800     uint32_t ret = imageSource->GetFilterArea(filterType, ranges);
801     ASSERT_NE(ret, 0);
802 
803     GTEST_LOG_(INFO) << "ImageSourceTest: GetFilterArea001 end";
804 }
805 
806 /**
807  * @tc.name: CreateImageSource001
808  * @tc.desc: test CreateImageSource is
809  * @tc.type: FUNC
810  */
811 HWTEST_F(ImageSourceTest, CreateImageSource001, TestSize.Level3)
812 {
813     GTEST_LOG_(INFO) << "ImageSourceTest: CreateImageSource001 start";
814 
815     std::unique_ptr<std::fstream> fs = std::make_unique<std::fstream>();
816     uint32_t errorCode = 0;
817     SourceOptions opts;
818     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(std::move(fs), opts, errorCode);
819     ASSERT_NE(imageSource, nullptr);
820 
821     GTEST_LOG_(INFO) << "ImageSourceTest: CreateImageSource001 end";
822 }
823 
824 /**
825  * @tc.name: CreateImageSource002
826  * @tc.desc: test CreateImageSource
827  * @tc.type: FUNC
828  */
829 HWTEST_F(ImageSourceTest, CreateImageSource002, TestSize.Level3)
830 {
831     GTEST_LOG_(INFO) << "ImageSourceTest: CreateImageSource002 start";
832 
833     std::unique_ptr<std::fstream> fs = std::make_unique<std::fstream>();
834     fs->open("/data/local/tmp/image/test.jpg", std::fstream::binary | std::fstream::in);
835     bool isOpen = fs->is_open();
836     ASSERT_EQ(isOpen, true);
837     uint32_t errorCode = 0;
838     SourceOptions opts;
839     opts.size.width = -1;
840     opts.size.height = -1;
841     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(std::move(fs), opts, errorCode);
842     ASSERT_NE(imageSource, nullptr);
843 
844     GTEST_LOG_(INFO) << "ImageSourceTest: CreateImageSource002 end";
845 }
846 
847 /**
848  * @tc.name: CreateImageSource009
849  * @tc.desc: test CreateImageSource buffer is nullptr
850  * @tc.type: FUNC
851  */
852 HWTEST_F(ImageSourceTest, CreateImageSource009, TestSize.Level3)
853 {
854     GTEST_LOG_(INFO) << "ImageSourceTest: CreateImageSource009 start";
855     size_t bufferSize = 0;
856     bool ret = ImageUtils::GetFileSize(IMAGE_INPUT_JPEG_PATH, bufferSize);
857     ASSERT_EQ(ret, true);
858     uint8_t *buffer = nullptr;
859 
860     uint32_t errorCode = 0;
861     SourceOptions opts;
862     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(buffer, bufferSize, opts, errorCode);
863     ASSERT_NE(errorCode, SUCCESS);
864     ASSERT_EQ(imageSource.get(), nullptr);
865     GTEST_LOG_(INFO) << "ImageSourceTest: CreateImageSource009 end";
866 }
867 
868 /**
869  * @tc.name: CreateImageSource0010
870  * @tc.desc: test CreateImageSource size is 0
871  * @tc.type: FUNC
872  */
873 HWTEST_F(ImageSourceTest, CreateImageSource0010, TestSize.Level3)
874 {
875     GTEST_LOG_(INFO) << "ImageSourceTest: CreateImageSource0010 start";
876     size_t bufferSize = 0;
877     bool ret = ImageUtils::GetFileSize(IMAGE_INPUT_JPEG_PATH, bufferSize);
878     ASSERT_EQ(ret, true);
879     uint8_t *buffer = reinterpret_cast<uint8_t *>(malloc(bufferSize));
880     ASSERT_NE(buffer, nullptr);
881 
882     uint32_t size = 0;
883     uint32_t errorCode = 0;
884     SourceOptions opts;
885     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(buffer, size, opts, errorCode);
886     ASSERT_NE(errorCode, SUCCESS);
887     ASSERT_EQ(imageSource.get(), nullptr);
888     GTEST_LOG_(INFO) << "ImageSourceTest: CreateImageSource0010 end";
889 }
890 
891 /**
892  * @tc.name: CreateImageSource0011
893  * @tc.desc: test CreateImageSource size is 0 and buffer is nullptr
894  * @tc.type: FUNC
895  */
896 HWTEST_F(ImageSourceTest, CreateImageSource0011, TestSize.Level3)
897 {
898     GTEST_LOG_(INFO) << "ImageSourceTest: CreateImageSource0011 start";
899     uint8_t *buffer = nullptr;
900 
901     uint32_t size = 0;
902     uint32_t errorCode = 0;
903     SourceOptions opts;
904     std::unique_ptr<ImageSource> imageSource = ImageSource::CreateImageSource(buffer, size, opts, errorCode);
905     ASSERT_NE(errorCode, SUCCESS);
906     ASSERT_EQ(imageSource.get(), nullptr);
907     GTEST_LOG_(INFO) << "ImageSourceTest: CreateImageSource0011 end";
908 }
909 } // namespace Multimedia
910 } // namespace OHOS