From bff0cda159346324fb276ce5d693c468968d8d6f Mon Sep 17 00:00:00 2001 From: baosiyuan Date: Tue, 17 Jun 2025 18:05:11 +0800 Subject: [PATCH] Add UT test cases Signed-off-by: baosiyuan Change-Id: I164b02d9068a7936edf1aa582ef91e91305ca5cf --- frameworks/innerkitsimpl/test/BUILD.gn | 15 +- .../exif_metadata_formatter_test.cpp | 57 +++++ .../exif_metadata_test.cpp | 74 ++++++ .../heif_exif_metadata_accessor_test.cpp | 16 ++ .../webp_exif_metadata_accessor_test.cpp | 240 ++++++++++++++++++ .../image_source_test/image_source_test.cpp | 16 ++ .../test/unittest/interface_test.cpp | 44 +++- .../unittest/jpeg_hw_decoder_test.cpp | 19 ++ .../test/unittest/picture_ext_test.cpp | 61 ++++- .../unittest/plugin_test/ext_decoder_test.cpp | 111 ++++++++ .../test/unittest/post_proc_test.cpp | 172 ++++++++++++- test/resource/image/ohos_test.xml | 1 + 12 files changed, 809 insertions(+), 17 deletions(-) diff --git a/frameworks/innerkitsimpl/test/BUILD.gn b/frameworks/innerkitsimpl/test/BUILD.gn index 94635c57a..71a71b174 100644 --- a/frameworks/innerkitsimpl/test/BUILD.gn +++ b/frameworks/innerkitsimpl/test/BUILD.gn @@ -633,7 +633,10 @@ ohos_unittest("interfacetest") { "//foundation/multimedia/image_framework/plugins/manager/include", ] - sources = [ "//foundation/multimedia/image_framework/frameworks/innerkitsimpl/test/unittest/interface_test.cpp" ] + sources = [ + "$image_subsystem/frameworks/innerkitsimpl/stream/src/incremental_source_stream.cpp", + "$image_subsystem/frameworks/innerkitsimpl/test/unittest/interface_test.cpp" + ] deps = [ "//foundation/multimedia/image_framework/frameworks/innerkitsimpl/utils:image_utils", @@ -737,7 +740,10 @@ ohos_unittest("convertertest") { ] sources = [ - "$image_subsystem/frameworks/innerkitsimpl/test/unittest/basic_transformer_test.cpp", + "${image_subsystem}/frameworks/innerkitsimpl/converter/src/post_proc_slr.cpp", + "${image_subsystem}/frameworks/innerkitsimpl/test/unittest/basic_transformer_test.cpp", + "${image_subsystem}/frameworks/innerkitsimpl/converter/src/post_proc.cpp", + "${image_subsystem}/frameworks/innerkitsimpl/converter/src/scan_line_filter.cpp", "//foundation/multimedia/image_framework/frameworks/innerkitsimpl/test/unittest/matrix_test.cpp", "//foundation/multimedia/image_framework/frameworks/innerkitsimpl/test/unittest/pixel_convert_test.cpp", "//foundation/multimedia/image_framework/frameworks/innerkitsimpl/test/unittest/post_proc_test.cpp", @@ -745,12 +751,16 @@ ohos_unittest("convertertest") { ] deps = [ + "${image_subsystem}/frameworks/innerkitsimpl/egl_image:post_proc_gl", "//foundation/multimedia/image_framework/frameworks/innerkitsimpl/utils:image_utils", "//foundation/multimedia/image_framework/interfaces/innerkits:image_native", ] resource_config_file = "$image_subsystem/test/resource/image/ohos_test.xml" external_deps = [ "c_utils:utils", + "drivers_interface_display:libdisplay_commontype_proxy_1.0", + "ffmpeg:libohosffmpeg", + "ffrt:libffrt", "googletest:gmock_main", "googletest:gtest_main", "graphic_2d:color_manager", @@ -1283,6 +1293,7 @@ ohos_unittest("jpeg_hw_decoder_test") { "${image_subsystem}/frameworks/innerkitsimpl/utils:image_utils", "${image_subsystem}/interfaces/innerkits:image_native", "${image_subsystem}/plugins/common/libs/image/libextplugin:extplugin", + "${image_subsystem}/plugins/common/libs/image/libextplugin:heifparser", "${image_subsystem}/plugins/common/libs/image/libextplugin:textureEncoderCL", ] diff --git a/frameworks/innerkitsimpl/test/unittest/exif_metadata_accessor_test/exif_metadata_formatter_test.cpp b/frameworks/innerkitsimpl/test/unittest/exif_metadata_accessor_test/exif_metadata_formatter_test.cpp index b481f6a23..ae4832e1e 100644 --- a/frameworks/innerkitsimpl/test/unittest/exif_metadata_accessor_test/exif_metadata_formatter_test.cpp +++ b/frameworks/innerkitsimpl/test/unittest/exif_metadata_accessor_test/exif_metadata_formatter_test.cpp @@ -13,6 +13,7 @@ * limitations under the License. */ +#define private public #include #include #include "exif_metadata_formatter.h" @@ -94,5 +95,61 @@ HWTEST_F(ExifMetadataFormatterTest, Validate002, TestSize.Level3) ASSERT_NE(ExifMetadatFormatter::Validate("GPSLongitudeRef", "C"), 0); GTEST_LOG_(INFO) << "ExifMetadataFormatterTest: Validate002 end"; } + +/** + * @tc.name: IsValidValueTest001 + * @tc.desc: test the IsValidValue when array is nullptr + * @tc.type: FUNC + */ +HWTEST_F(ExifMetadataFormatterTest, IsValidValueTest001, TestSize.Level3) +{ + ASSERT_FALSE(ExifMetadatFormatter::IsValidValue(nullptr, 0, 0)); +} + +/** + * @tc.name: RationalFormat001 + * @tc.desc: test the RationalFormat for nomatched value + * @tc.type: FUNC + */ +HWTEST_F(ExifMetadataFormatterTest, RationalFormat001, TestSize.Level3) +{ + std::string value = "12 abc"; + ExifMetadatFormatter::RationalFormat(value); + EXPECT_EQ(value, "12/1"); +} + +/** + * @tc.name: GetFractionFromStrTest001 + * @tc.desc: Test GetFractionFromStr when int part out of range + * @tc.type: FUNC + */ +HWTEST_F(ExifMetadataFormatterTest, GetFractionFromStrTest001, TestSize.Level3) +{ + bool isOutRange = false; + std::string result = ExifMetadatFormatter::GetFractionFromStr("abc.5", isOutRange); + EXPECT_EQ(result, ""); + EXPECT_TRUE(isOutRange); +} + +/** + * @tc.name: GetFractionFromStrTest002 + * @tc.desc: Test GetFractionFromStr when the input is a valid decimal number + * @tc.type: FUNC + */ +HWTEST_F(ExifMetadataFormatterTest, GetFractionFromStrTest002, TestSize.Level3) +{ + bool isOutRange = false; + std::string result = ExifMetadatFormatter::GetFractionFromStr("2.5", isOutRange); + EXPECT_EQ(result, "5/2"); + EXPECT_FALSE(isOutRange); + + result = ExifMetadatFormatter::GetFractionFromStr("10.25", isOutRange); + EXPECT_EQ(result, "41/4"); + EXPECT_FALSE(isOutRange); + + result = ExifMetadatFormatter::GetFractionFromStr("7.0", isOutRange); + EXPECT_EQ(result, "7/1"); + EXPECT_FALSE(isOutRange); +} } // namespace Multimedia } // namespace OHOS diff --git a/frameworks/innerkitsimpl/test/unittest/exif_metadata_accessor_test/exif_metadata_test.cpp b/frameworks/innerkitsimpl/test/unittest/exif_metadata_accessor_test/exif_metadata_test.cpp index 524d25b35..1c8405334 100644 --- a/frameworks/innerkitsimpl/test/unittest/exif_metadata_accessor_test/exif_metadata_test.cpp +++ b/frameworks/innerkitsimpl/test/unittest/exif_metadata_accessor_test/exif_metadata_test.cpp @@ -1844,5 +1844,79 @@ HWTEST_F(ExifMetadataTest, SetAndGetMakerNoteValueTest001, TestSize.Level3) ASSERT_EQ(getValue, value); GTEST_LOG_(INFO) << "ExifMetadataTest: SetAndGetMakerNoteValueTest001 end"; } + +/** + * @tc.name: CreateExifdataTest001 + * @tc.desc: Verify that ExifMetadata CreateExifdata is success when exifData_ is not nullptr. + * @tc.type: FUNC + */ +HWTEST_F(ExifMetadataTest, CreateExifdataTest001, TestSize.Level3) +{ + auto exifData = exif_data_new_from_file(IMAGE_INPUT_JPEG_PATH.c_str()); + ASSERT_NE(exifData, nullptr); + ExifMetadata metadata(exifData); + EXPECT_TRUE(metadata.CreateExifdata()); + ASSERT_NE(metadata.exifData_, nullptr); +} + + +/** + * @tc.name: SetMakerNoteValueTest002 + * @tc.desc: Verify that ExifMetadata SetMakerNoteValue when head is HUAWEI_HEADER. + * @tc.type: FUNC + */ +HWTEST_F(ExifMetadataTest, SetMakerNoteValueTest002, TestSize.Level3) +{ + auto exifData = exif_data_new_from_file(IMAGE_INPUT_JPEG_PATH.c_str()); + ASSERT_NE(exifData, nullptr); + ExifMetadata metadata(exifData); + std::string value1 = std::string{HUAWEI_HEADER} + "MOCKVALUE"; + EXPECT_TRUE(metadata.SetMakerNoteValue(value1)); + const unsigned char hwData[] = { + 0x48, 0x55, 0x41, 0x57, 0x45, 0x49, 0x00, + 0x00, 0x4D, 0x4D, 0x00, 0x2A, 0x00, 0x00, 0x00, 0x08, 0x00, 0x01, 0x02, 0x00, + 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00 + }; + std::string value2(reinterpret_cast(hwData), sizeof(hwData)); + EXPECT_TRUE(metadata.SetMakerNoteValue(value2)); +} + +/** + * @tc.name: SetHwMoteValueTest001 + * @tc.desc: Verify that ExifMetadata SetHwMoteValue when key is "HwMnoteFocusModeExif". + * @tc.type: FUNC + */ +HWTEST_F(ExifMetadataTest, SetHwMoteValueTest001, TestSize.Level3) +{ + auto exifData = exif_data_new_from_file(IMAGE_INPUT_JPEG_PATH.c_str()); + ASSERT_NE(exifData, nullptr); + ExifMetadata metadata(exifData); + EXPECT_FALSE(metadata.SetHwMoteValue("HwMnoteFocusModeExif", "0")); +} + +/** + * @tc.name: GetFilterAreaTest001 + * @tc.desc: Verify that ExifMetadata GetFilterArea. + * @tc.type: FUNC + */ +HWTEST_F(ExifMetadataTest, GetFilterAreaTest001, TestSize.Level3) +{ + std::vector exifKeys = {}; + std::vector> ranges = {}; + ExifMetadata metadataNull; + metadataNull.GetFilterArea(exifKeys, ranges); + ASSERT_EQ(exifKeys.size(), 0); + ASSERT_EQ(ranges.size(), 0); + + exifKeys.push_back("TestKey"); + exifKeys.push_back("GPSDestLongitude"); + auto exifData = exif_data_new_from_file(IMAGE_INPUT_JPEG_PATH.c_str()); + ASSERT_NE(exifData, nullptr); + ExifMetadata metadata(exifData); + metadata.SetValue("GPSDestLongitude", "123/1 456/1 789/1"); + metadata.GetFilterArea(exifKeys, ranges); + ASSERT_TRUE(ranges.size() > 0); +} } // namespace Multimedia } // namespace OHOS diff --git a/frameworks/innerkitsimpl/test/unittest/exif_metadata_accessor_test/heif_exif_metadata_accessor_test.cpp b/frameworks/innerkitsimpl/test/unittest/exif_metadata_accessor_test/heif_exif_metadata_accessor_test.cpp index 3fac9e723..80a2dc6f1 100644 --- a/frameworks/innerkitsimpl/test/unittest/exif_metadata_accessor_test/heif_exif_metadata_accessor_test.cpp +++ b/frameworks/innerkitsimpl/test/unittest/exif_metadata_accessor_test/heif_exif_metadata_accessor_test.cpp @@ -325,5 +325,21 @@ HWTEST_F(HeifExifMetadataAccessorTest, WriteMetadata002, TestSize.Level3) res = imageAccessor.CheckTiffPos(buff, 0, byteOrderPos); EXPECT_FALSE(res); } + +/** + * @tc.name: Read012 + * @tc.desc: test the Read method when fp_ is nullptr. + * @tc.type: FUNC + */ +HWTEST_F(HeifExifMetadataAccessorTest, Read012, TestSize.Level3) +{ + auto fileStream = std::make_shared(IMAGE_INPUT_HEIF_EXIF_PATH); + ASSERT_NE(fileStream, nullptr); + std::shared_ptr stream = fileStream; + ASSERT_NE(stream, nullptr); + HeifExifMetadataAccessor imageAccessor(stream); + uint32_t res = imageAccessor.Read(); + EXPECT_EQ(res, ERR_IMAGE_SOURCE_DATA); +} } // namespace Multimedia } // namespace OHOS \ No newline at end of file diff --git a/frameworks/innerkitsimpl/test/unittest/exif_metadata_accessor_test/webp_exif_metadata_accessor_test.cpp b/frameworks/innerkitsimpl/test/unittest/exif_metadata_accessor_test/webp_exif_metadata_accessor_test.cpp index 28486ab91..233b4d988 100644 --- a/frameworks/innerkitsimpl/test/unittest/exif_metadata_accessor_test/webp_exif_metadata_accessor_test.cpp +++ b/frameworks/innerkitsimpl/test/unittest/exif_metadata_accessor_test/webp_exif_metadata_accessor_test.cpp @@ -34,6 +34,7 @@ namespace { constexpr auto IMAGE_INPUT_READ1_WEBP_SIZE = 25294; constexpr auto IMAGE_INPUT_READ6_WEBP_SIZE = 570; constexpr auto IMAGE_INPUT_READ8_WEBP_SIZE = 4244; +constexpr auto WEBP_HEAD_SIZE = 8; constexpr auto WEBP_CHUNK_HEADER_ANMF = "ANMF"; constexpr auto WEBP_CHUNK_HEADER_VP8L = "VP8L"; static const std::string IMAGE_INPUT_READ1_WEBP_PATH = "/data/local/tmp/image/test_webp_readexifblob001.webp"; @@ -1787,5 +1788,244 @@ HWTEST_F(WebpExifMetadataAccessorTest, ReadBlob011, TestSize.Level3) bool res = imageReadAccessor.ReadBlob(blob); EXPECT_TRUE(res); } + +/** + * @tc.name: ReadBlob003 + * @tc.desc: test ReadExifBlob with not open. + * @tc.type: FUNC + */ +HWTEST_F(WebpExifMetadataAccessorTest, ReadBlob003, TestSize.Level3) +{ + std::shared_ptr readStream = std::make_shared(IMAGE_INPUT_READ1_WEBP_PATH); + WebpExifMetadataAccessor imageReadAccessor(readStream); + DataBuf exifBuf; + bool result = imageReadAccessor.ReadBlob(exifBuf); + EXPECT_TRUE(result); + EXPECT_EQ(exifBuf.Size(), IMAGE_INPUT_READ1_WEBP_SIZE); +} + +/** + * @tc.name: GetImageWidthAndHeight001 + * @tc.desc: Verify GetImageWidthAndHeight() returns (0, 0) when the stream is at EOF. + * @tc.type: FUNC + */ +HWTEST_F(WebpExifMetadataAccessorTest, GetImageWidthAndHeight001, TestSize.Level3) +{ + class MockStream : public FileMetadataStream { + public: + explicit MockStream(std::string path) : FileMetadataStream(path) {} + bool IsEof() override { return true; } + }; + std::shared_ptr mockStream = std::make_shared(IMAGE_INPUT_READ1_WEBP_PATH); + WebpExifMetadataAccessor accessor(mockStream); + auto [width, height] = accessor.GetImageWidthAndHeight(); + EXPECT_EQ(width, 0); + EXPECT_EQ(height, 0); +} + +/** + * @tc.name: GetImageWidthAndHeight002 + * @tc.desc: Verify GetImageWidthAndHeight() returns (0, 0) when the stream returns no data on read. + * @tc.type: FUNC + */ +HWTEST_F(WebpExifMetadataAccessorTest, GetImageWidthAndHeight002, TestSize.Level3) +{ + class MockStream : public FileMetadataStream { + public: + explicit MockStream(std::string path) : FileMetadataStream(path) {} + bool IsEof() override { return false; } + ssize_t Read(byte *buf, ssize_t size) override { return 0; } + }; + std::shared_ptr mockStream = std::make_shared(IMAGE_INPUT_READ1_WEBP_PATH); + WebpExifMetadataAccessor accessor(mockStream); + auto [width, height] = accessor.GetImageWidthAndHeight(); + EXPECT_EQ(width, 0); + EXPECT_EQ(height, 0); +} + +/** + * @tc.name: GetImageWidthAndHeight003 + * @tc.desc: Verify GetImageWidthAndHeight() returns (0, 0) when reading insufficient data (partial header). + * @tc.type: FUNC + */ +HWTEST_F(WebpExifMetadataAccessorTest, GetImageWidthAndHeight003, TestSize.Level3) +{ + class MockStream : public FileMetadataStream { + public: + explicit MockStream(std::string path) : FileMetadataStream(path) {} + bool IsEof() override { return false; } + ssize_t Read(byte *buf, ssize_t size) override { return WEBP_HEAD_SIZE; } + }; + std::shared_ptr mockStream = std::make_shared(IMAGE_INPUT_READ1_WEBP_PATH); + WebpExifMetadataAccessor accessor(mockStream); + auto [width, height] = accessor.GetImageWidthAndHeight(); + EXPECT_EQ(width, 0); + EXPECT_EQ(height, 0); +} + +/** + * @tc.name: GetImageWidthAndHeight004 + * @tc.desc: Verify GetImageWidthAndHeight() returns (0, 0) when reading corrupted/unsupported WebP data. + * @tc.type: FUNC + */ +HWTEST_F(WebpExifMetadataAccessorTest, GetImageWidthAndHeight004, TestSize.Level3) +{ + class MockStream : public FileMetadataStream { + public: + explicit MockStream(std::string path) : FileMetadataStream(path) {} + bool IsEof() override { return false; } + ssize_t Read(byte *buf, ssize_t size) override + { + if (buf == nullptr || size == 0) { + return 0; + } + buf[0] = 1; + buf[size - 1] = 1; + return size; + } + ssize_t GetSize() override { return 0; } + long Tell() override { return 0; } + }; + std::shared_ptr mockStream = std::make_shared(IMAGE_INPUT_READ1_WEBP_PATH); + WebpExifMetadataAccessor accessor(mockStream); + auto [width, height] = accessor.GetImageWidthAndHeight(); + EXPECT_EQ(width, 0); + EXPECT_EQ(height, 0); +} + +/** + * @tc.name: CheckChunkVp8x001 + * @tc.desc: Verify CheckChunkVp8x() returns false when invalid VP8X chunk data is read (zero-filled buffer). + * @tc.type: FUNC + */ +HWTEST_F(WebpExifMetadataAccessorTest, CheckChunkVp8x001, TestSize.Level3) +{ + class MockStream : public FileMetadataStream { + public: + explicit MockStream(std::string path) : FileMetadataStream(path) {} + bool IsEof() override { return false; } + ssize_t Read(byte *buf, ssize_t size) override + { + if (size != 0) { + buf[0] = 0; + } + return size; + } + }; + std::shared_ptr mockStream = std::make_shared(IMAGE_INPUT_READ1_WEBP_PATH); + WebpExifMetadataAccessor accessor(mockStream); + Vp8xAndExifInfo exifFlag; + bool ret = accessor.CheckChunkVp8x(exifFlag); + EXPECT_FALSE(ret); +} + +/** + * @tc.name: InsertExifMetadata001 + * @tc.desc: Verify InsertExifMetadata() returns false when given invalid/null Exif data. + * @tc.type: FUNC + */ +HWTEST_F(WebpExifMetadataAccessorTest, InsertExifMetadata001, TestSize.Level3) +{ + class MockStream : public BufferMetadataStream { + public: + ssize_t Write(uint8_t *data, ssize_t size) override { return size + 1; } + }; + class MockFileStream : public FileMetadataStream { + public: + explicit MockFileStream(std::string path) : FileMetadataStream(path) {} + ssize_t Read(byte *buf, ssize_t size) override { return 0; } + }; + MockStream mockStream; + std::shared_ptr mockFileStream = std::make_shared(IMAGE_INPUT_READ1_WEBP_PATH); + WebpExifMetadataAccessor accessor(mockFileStream); + bool ret = accessor.InsertExifMetadata(mockStream, nullptr, 0); + EXPECT_FALSE(ret); +} + +/** + * @tc.name: InsertExifMetadata002 + * @tc.desc: Verify InsertExifMetadata() fails when writing Exif data begins with 'E' (0x45) but source is invalid. + * @tc.type: FUNC + */ +HWTEST_F(WebpExifMetadataAccessorTest, InsertExifMetadata002, TestSize.Level3) +{ + class MockStream : public BufferMetadataStream { + public: + ssize_t Write(uint8_t *data, ssize_t size) override + { + if (size != 0 && data[0] == 0x45) { + return size; + } + return size + 1; + } + }; + class MockFileStream : public FileMetadataStream { + public: + explicit MockFileStream(std::string path) : FileMetadataStream(path) {} + ssize_t Read(byte *buf, ssize_t size) override { return 0; } + }; + MockStream mockStream; + std::shared_ptr mockFileStream = std::make_shared(IMAGE_INPUT_READ1_WEBP_PATH); + WebpExifMetadataAccessor accessor(mockFileStream); + bool ret = accessor.InsertExifMetadata(mockStream, nullptr, 0); + EXPECT_FALSE(ret); +} + +/** + * @tc.name: InsertExifMetadata003 + * @tc.desc: Verify InsertExifMetadata() fails when writing Exif data of size 1 with starting byte 0x01 returns + * incorrect write size. + * @tc.type: FUNC + */ +HWTEST_F(WebpExifMetadataAccessorTest, InsertExifMetadata003, TestSize.Level3) +{ + class MockStream : public BufferMetadataStream { + public: + ssize_t Write(uint8_t *data, ssize_t size) override + { + if (size != 0 && data[0] == 0x01) { + return size + 1; + } + return size; + } + }; + class MockFileStream : public FileMetadataStream { + public: + explicit MockFileStream(std::string path) : FileMetadataStream(path) {} + ssize_t Read(byte *buf, ssize_t size) override { return 0; } + }; + MockStream mockStream; + std::shared_ptr mockFileStream = std::make_shared(IMAGE_INPUT_READ1_WEBP_PATH); + WebpExifMetadataAccessor accessor(mockFileStream); + bool ret = accessor.InsertExifMetadata(mockStream, nullptr, 1); + EXPECT_FALSE(ret); +} + +/** + * @tc.name: InsertExifMetadata004 + * @tc.desc: Verify InsertExifMetadata() succeeds when writing valid 1-byte Exif data (0x01) with matching write size. + * @tc.type: FUNC + */ +HWTEST_F(WebpExifMetadataAccessorTest, InsertExifMetadata004, TestSize.Level3) +{ + class MockStream : public BufferMetadataStream { + public: + ssize_t Write(uint8_t *data, ssize_t size) override + { + return size; + } + }; + class MockFileStream : public FileMetadataStream { + public: + explicit MockFileStream(std::string path) : FileMetadataStream(path) {} + ssize_t Read(byte *buf, ssize_t size) override { return 0; } + }; + MockStream mockStream; + std::shared_ptr mockFileStream = std::make_shared(IMAGE_INPUT_READ1_WEBP_PATH); + WebpExifMetadataAccessor accessor(mockFileStream); + uint8_t data[] = {0x01}; + bool ret = accessor.InsertExifMetadata(mockStream, data, 1); + EXPECT_TRUE(ret); +} } // namespace Multimedia } // namespace OHOS diff --git a/frameworks/innerkitsimpl/test/unittest/image_source_test/image_source_test.cpp b/frameworks/innerkitsimpl/test/unittest/image_source_test/image_source_test.cpp index f85c4665e..2f7032858 100644 --- a/frameworks/innerkitsimpl/test/unittest/image_source_test/image_source_test.cpp +++ b/frameworks/innerkitsimpl/test/unittest/image_source_test/image_source_test.cpp @@ -1598,6 +1598,22 @@ HWTEST_F(ImageSourceTest, GetFormatExtendedTest001, TestSize.Level3) ASSERT_EQ(ret, ERR_MEDIA_NULL_POINTER); } +/** + * @tc.name: GetFormatExtendedTest002 + * @tc.desc: Verify GetFormatExtended() returns SUCCESS when called with null decoder and empty format string. + * @tc.type: FUNC + */ +HWTEST_F(ImageSourceTest, GetFormatExtendedTest002, TestSize.Level1) +{ + uint32_t errorCode = 0; + SourceOptions opts; + std::unique_ptr imageSource = ImageSource::CreateImageSource(IMAGE_INPUT_JPEG_PATH, opts, errorCode); + imageSource->mainDecoder_ = nullptr; + std::string format = ""; + uint32_t ret = imageSource->GetFormatExtended(format); + EXPECT_EQ(ret, SUCCESS); +} + /** * @tc.name: CheckFormatHintTest001 * @tc.desc: test CheckFormatHint diff --git a/frameworks/innerkitsimpl/test/unittest/interface_test.cpp b/frameworks/innerkitsimpl/test/unittest/interface_test.cpp index cf8dbd930..6a73da6ab 100644 --- a/frameworks/innerkitsimpl/test/unittest/interface_test.cpp +++ b/frameworks/innerkitsimpl/test/unittest/interface_test.cpp @@ -16,19 +16,22 @@ #include #include #include +#define private public #include "directory_ex.h" +#include "graphic_common.h" #include "image_packer.h" #include "image_source.h" #include "image_type.h" #include "image_utils.h" +#include "image_receiver.h" +#include "image_receiver_manager.h" +#include "image_source_util.h" #include "incremental_pixel_map.h" +#include "incremental_source_stream.h" #include "media_errors.h" #include "pixel_map.h" #include "pixel_map_manager.h" -#include "image_receiver.h" -#include "image_source_util.h" -#include "graphic_common.h" -#include "image_receiver_manager.h" + using namespace testing::ext; using namespace OHOS::Media; @@ -258,5 +261,38 @@ HWTEST_F(InterfaceTest, InterfaceTest0012, TestSize.Level3) ASSERT_EQ(tmp, SUCCESS); GTEST_LOG_(INFO) << "InterfaceTest: InterfaceTest0012 end"; } + +/** + * @tc.name: PromoteDecodingTest001 + * @tc.desc: Test PromoteDecoding when imageSource is nullptr and decodingState is + * BASE_INFO_ERROR or IMAGE_ERROR or others. + * @tc.type: FUNC + */ +HWTEST_F(InterfaceTest, PromoteDecodingTest001, TestSize.Level3) +{ + GTEST_LOG_(INFO) << "InterfaceTest: PromoteDecodingTest001 start"; + unique_ptr incrementalSourceStream = + std::make_unique(IncrementalMode::INCREMENTAL_DATA); + unique_ptr sourceStream = std::move(incrementalSourceStream); + SourceOptions sourceOpts; + DecodeOptions decodeOpts; + ImageSource imageSource(std::move(sourceStream), sourceOpts); + IncrementalPixelMap incrementalPixelMap(0, decodeOpts, &imageSource); + incrementalPixelMap.imageSource_ = nullptr; + incrementalPixelMap.decodingStatus_.state = IncrementalDecodingState::UNRESOLVED; + uint8_t decodeProgress = 0; + + uint32_t errCode = incrementalPixelMap.PromoteDecoding(decodeProgress); + EXPECT_EQ(errCode, ERR_IMAGE_SOURCE_DATA); + + incrementalPixelMap.decodingStatus_.state = IncrementalDecodingState::BASE_INFO_ERROR; + errCode = incrementalPixelMap.PromoteDecoding(decodeProgress); + EXPECT_EQ(errCode, 0); + + incrementalPixelMap.decodingStatus_.state = IncrementalDecodingState::IMAGE_ERROR; + errCode = incrementalPixelMap.PromoteDecoding(decodeProgress); + EXPECT_EQ(errCode, 0); + GTEST_LOG_(INFO) << "InterfaceTest: PromoteDecodingTest001 end"; +} } } \ No newline at end of file diff --git a/frameworks/innerkitsimpl/test/unittest/jpeg_hw_decode/unittest/jpeg_hw_decoder_test.cpp b/frameworks/innerkitsimpl/test/unittest/jpeg_hw_decode/unittest/jpeg_hw_decoder_test.cpp index db28fb461..487336aad 100644 --- a/frameworks/innerkitsimpl/test/unittest/jpeg_hw_decode/unittest/jpeg_hw_decoder_test.cpp +++ b/frameworks/innerkitsimpl/test/unittest/jpeg_hw_decode/unittest/jpeg_hw_decoder_test.cpp @@ -126,6 +126,25 @@ HWTEST_F(JpegHwDecoderTest, IsHardwareDecodeSupportedTest002, TestSize.Level3) GTEST_LOG_(INFO) << "JpegHwDecoderTest: IsHardwareDecodeSupportedTest002 end"; } +/** + * @tc.name: IsHardwareDecodeSupportedTest003 + * @tc.desc: Verify hardware decode support check returns false for empty file path, zero size, and null decoder cases. + * @tc.type: FUNC + */ +HWTEST_F(JpegHwDecoderTest, IsHardwareDecodeSupportedTest003, TestSize.Level3) +{ + GTEST_LOG_(INFO) << "JpegHwDecoderTest: IsHardwareDecodeSupportedTest003 start"; + JpegHardwareDecoder jpegHardwareDecoder; + ASSERT_NE(jpegHardwareDecoder.hwDecoder_, nullptr); + Media::Size size = {0, 0}; + bool ret = jpegHardwareDecoder.IsHardwareDecodeSupported("", size); + EXPECT_FALSE(ret); + jpegHardwareDecoder.hwDecoder_ = nullptr; + ret = jpegHardwareDecoder.IsHardwareDecodeSupported("", size); + EXPECT_FALSE(ret); + GTEST_LOG_(INFO) << "JpegHwDecoderTest: IsHardwareDecodeSupportedTest003 end"; +} + /** * @tc.name: CheckInputColorFmtTest001 * @tc.desc: test the CheckInputColorFmt diff --git a/frameworks/innerkitsimpl/test/unittest/picture_ext_test.cpp b/frameworks/innerkitsimpl/test/unittest/picture_ext_test.cpp index 106240873..4397d5af7 100644 --- a/frameworks/innerkitsimpl/test/unittest/picture_ext_test.cpp +++ b/frameworks/innerkitsimpl/test/unittest/picture_ext_test.cpp @@ -51,8 +51,8 @@ static const std::string IMAGE_JPEG_SRC = "/data/local/tmp/image/test_jpeg.jpg"; static const std::string IMAGE_JPEG_DEST = "/data/local/tmp/image/test_jpeg_out.jpg"; static const std::string IMAGE_HEIF_SRC = "/data/local/tmp/image/test_heif.heic"; static const std::string IMAGE_HEIF_DEST = "/data/local/tmp/image/test_heif_out.heic"; -static const std::string IMAGE_INPUT_JPEGHDR_PATH = "/data/local/tmp/image/test_jpeg_hdr.jpg"; -static const std::string IMAGE_INPUT_HEIFHDR_PATH = "/data/local/tmp/image/test_heif_hdr.heic"; +static const std::string IMAGE_JPEGHDR_SRC = "/data/local/tmp/image/test_jpeg_hdr.jpg"; +static const std::string IMAGE_HEIFHDR_SRC = "/data/local/tmp/image/test_heif_hdr.heic"; static const std::string IMAGE_JPEG_WRONG_SRC = "/data/local/tmp/image/test_picture_wrong.jpg"; static const std::string IMAGE_HEIC_64_64 = "/data/local/tmp/image/test_heic_64_64.heic"; static const std::string IMAGE_HEIC_128_128 = "/data/local/tmp/image/test_heic_128_128.heic"; @@ -147,7 +147,7 @@ static OH_PictureNative* CreatePictureNative() OH_PictureNative *CreateNativePicture(std::vector& ayxTypeList) { std::string realPath; - if (!ImageUtils::PathToRealPath(IMAGE_INPUT_JPEGHDR_PATH.c_str(), realPath)) { + if (!ImageUtils::PathToRealPath(IMAGE_JPEGHDR_SRC.c_str(), realPath)) { return nullptr; } if (realPath.c_str() == nullptr) { @@ -309,6 +309,23 @@ HWTEST_F(PictureExtTest, CreatePicture006, TestSize.Level3) EXPECT_NE(picture, nullptr); } +/** + * @tc.name: CreatePictureTest007 + * @tc.desc: Verify CreatePicture() fails as expected when creating picture from GIF format. + * @tc.type: FUNC + */ +HWTEST_F(PictureExtTest, CreatePicture007, TestSize.Level3) +{ + uint32_t errorCode = -1; + SourceOptions opts; + std::unique_ptr imageSource = ImageSource::CreateImageSource(IMAGE_GIF_PATH, opts, errorCode); + ASSERT_EQ(errorCode, OHOS::Media::SUCCESS); + ASSERT_NE(imageSource, nullptr); + DecodingOptionsForPicture dstOpts; + std::unique_ptr picture = imageSource->CreatePicture(dstOpts, errorCode); + EXPECT_EQ(picture, nullptr); +} + bool EncodePictureMethodOne(std::shared_ptr picture, std::string format, std::string IMAGE_DEST) { const int fileSize = 1024 * 1024 * 35; // 35M @@ -705,7 +722,7 @@ HWTEST_F(PictureExtTest, getHDRComposedPixelmapTest001, TestSize.Level1) uint32_t res = 0; SourceOptions sourceOpts; sourceOpts.formatHint = "image/jpeg"; - std::unique_ptr imageSource = ImageSource::CreateImageSource(IMAGE_INPUT_JPEGHDR_PATH.c_str(), + std::unique_ptr imageSource = ImageSource::CreateImageSource(IMAGE_JPEGHDR_SRC.c_str(), sourceOpts, res); ASSERT_NE(imageSource, nullptr); DecodingOptionsForPicture opts; @@ -730,7 +747,7 @@ HWTEST_F(PictureExtTest, getHDRComposedPixelmapTest002, TestSize.Level2) { uint32_t res = 0; SourceOptions sourceOpts; - std::unique_ptr imageSource = ImageSource::CreateImageSource(IMAGE_INPUT_JPEGHDR_PATH.c_str(), + std::unique_ptr imageSource = ImageSource::CreateImageSource(IMAGE_JPEGHDR_SRC.c_str(), sourceOpts, res); ASSERT_NE(imageSource, nullptr); DecodingOptionsForPicture opts; @@ -753,7 +770,7 @@ HWTEST_F(PictureExtTest, getHDRComposedPixelmapTest003, TestSize.Level1) uint32_t res = 0; SourceOptions sourceOpts; sourceOpts.formatHint = "image/heif"; - std::unique_ptr imageSource = ImageSource::CreateImageSource(IMAGE_INPUT_HEIFHDR_PATH.c_str(), + std::unique_ptr imageSource = ImageSource::CreateImageSource(IMAGE_HEIFHDR_SRC.c_str(), sourceOpts, res); ASSERT_NE(imageSource, nullptr); DecodingOptionsForPicture opts; @@ -778,7 +795,7 @@ HWTEST_F(PictureExtTest, getHDRComposedPixelmapTest004, TestSize.Level2) uint32_t res = 0; SourceOptions sourceOpts; sourceOpts.formatHint = "image/heif"; - std::unique_ptr imageSource = ImageSource::CreateImageSource(IMAGE_INPUT_HEIFHDR_PATH.c_str(), + std::unique_ptr imageSource = ImageSource::CreateImageSource(IMAGE_HEIFHDR_SRC.c_str(), sourceOpts, res); ASSERT_NE(imageSource, nullptr); DecodingOptionsForPicture opts; @@ -791,6 +808,34 @@ HWTEST_F(PictureExtTest, getHDRComposedPixelmapTest004, TestSize.Level2) EXPECT_EQ(pixelmap, nullptr); } +/** + * @tc.name: getHDRComposedPixelmapTest005 + * @tc.desc: Verify GetHdrComposedPixelMap() succeeds for HDR HEIF images with different P010 pixel formats. + * @tc.type: FUNC + */ +HWTEST_F(PictureExtTest, getHDRComposedPixelmapTest005, TestSize.Level1) +{ + uint32_t errorCode = 0; + SourceOptions sourceOpts; + std::unique_ptr imageSource = ImageSource::CreateImageSource(IMAGE_HEIFHDR_SRC.c_str(), + sourceOpts, errorCode); + ASSERT_NE(imageSource, nullptr); + DecodingOptionsForPicture opts; + opts.desiredPixelFormat = PixelFormat::YCBCR_P010; + std::unique_ptr picture = imageSource->CreatePicture(opts, errorCode); + ASSERT_EQ(errorCode, OHOS::Media::SUCCESS); + ASSERT_NE(picture, nullptr); + auto ret = picture->GetHdrComposedPixelMap(); + EXPECT_NE(ret, nullptr); + + opts.desiredPixelFormat = Media::PixelFormat::YCRCB_P010; + picture = imageSource->CreatePicture(opts, errorCode); + ASSERT_EQ(errorCode, OHOS::Media::SUCCESS); + ASSERT_NE(picture, nullptr); + ret = picture->GetHdrComposedPixelMap(); + EXPECT_NE(ret, nullptr); +} + /** * @tc.name: SetMaintenanceDataTest001 * @tc.desc: Set maintenance data successfully. @@ -1264,7 +1309,7 @@ HWTEST_F(PictureExtTest, CalGainmapTest001, TestSize.Level1) uint32_t res = 0; SourceOptions sourceOpts; sourceOpts.formatHint = "image/jpeg"; - std::unique_ptr imageSource = ImageSource::CreateImageSource(IMAGE_INPUT_JPEGHDR_PATH.c_str(), + std::unique_ptr imageSource = ImageSource::CreateImageSource(IMAGE_JPEGHDR_SRC.c_str(), sourceOpts, res); ASSERT_NE(imageSource, nullptr); DecodingOptionsForPicture opts; diff --git a/frameworks/innerkitsimpl/test/unittest/plugin_test/ext_decoder_test.cpp b/frameworks/innerkitsimpl/test/unittest/plugin_test/ext_decoder_test.cpp index c59d567ec..034ca2185 100644 --- a/frameworks/innerkitsimpl/test/unittest/plugin_test/ext_decoder_test.cpp +++ b/frameworks/innerkitsimpl/test/unittest/plugin_test/ext_decoder_test.cpp @@ -21,6 +21,7 @@ #include "ext_wstream.h" #include "ext_decoder.h" #include "plugin_export.h" +#include "image_packer.h" #include "ext_encoder.h" #include "ext_stream.h" #include "mock_data_stream.h" @@ -60,6 +61,8 @@ const static string SUPPORT_SCALE_KEY = "SupportScale"; const static string SUPPORT_CROP_KEY = "SupportCrop"; const static string EXT_SHAREMEM_NAME = "EXT RawData"; const static string IMAGE_INPUT_JPEG_PATH = "/data/local/tmp/image/test_hw1.jpg"; +static const std::string IMAGE_DEST = "/data/local/tmp/image/test_encode_out.dat"; +static const std::string IMAGE_HEIFHDR_SRC = "/data/local/tmp/image/test_heif_hdr.heic"; class ExtDecoderTest : public testing::Test { public: ExtDecoderTest() {} @@ -841,6 +844,22 @@ HWTEST_F(ExtDecoderTest, FinalizeEncodeTest001, TestSize.Level3) GTEST_LOG_(INFO) << "ExtDecoderTest: FinalizeEncodeTest001 end"; } +/** + * @tc.name: FinalizeEncodeTest002 + * @tc.desc: Verify FinalizePacking() returns expected error with invalid parameters. + * @tc.type: FUNC + */ +HWTEST_F(ExtDecoderTest, FinalizeEncodeTest002, TestSize.Level3) +{ + ImagePacker pack; + PackOption option; + option.format = "image/jpeg"; + uint32_t ret = pack.StartPacking(IMAGE_DEST, option); + ASSERT_EQ(ret, OHOS::Media::SUCCESS); + ret = pack.FinalizePacking(); + EXPECT_EQ(ret, ERR_IMAGE_INVALID_PARAMETER); +} + /** * @tc.name: readTest001 * @tc.desc: Test of read @@ -1064,6 +1083,20 @@ HWTEST_F(ExtDecoderTest, IsHardwareEncodeSupportedTest001, TestSize.Level3) GTEST_LOG_(INFO) << "ExtDecoderTest: IsHardwareEncodeSupportedTest001 end"; } +/** + * @tc.name: IsHardwareEncodeSupportedTest002 + * @tc.desc: Verify hardware encoding is not supported with invalid PixelMap parameter. + * @tc.type: FUNC + */ +HWTEST_F(ExtDecoderTest, IsHardwareEncodeSupportedTest002, TestSize.Level3) +{ + ExtEncoder encoder; + PlEncodeOptions opts; + Media::PixelMap *pixelMap = nullptr; + bool res = encoder.IsHardwareEncodeSupported(opts, pixelMap); + EXPECT_FALSE(res); +} + /** @tc.name: DoHardWareEncodeTest001 @tc.desc: Test of DoHardWareEncode @@ -1830,6 +1863,21 @@ HWTEST_F(ExtDecoderTest, EncodeHeifByPixelmapTest001, TestSize.Level3) GTEST_LOG_(INFO) << "ExtDecoderTest: EncodeHeifByPixelmapTest001 end"; } +/** + * @tc.name: EncodeHeifByPixelmapTest002 + * @tc.desc: Verify HEIF encoding fails with invalid PixelMap and null output. + * @tc.type: FUNC + */ +HWTEST_F(ExtDecoderTest, EncodeHeifByPixelmapTest002, TestSize.Level3) +{ + ExtEncoder encoder; + PlEncodeOptions opts; + Media::PixelMap *pixelMap = nullptr; + encoder.output_ = nullptr; + uint32_t res = encoder.EncodeHeifByPixelmap(pixelMap, opts); + EXPECT_EQ(res, ERR_IMAGE_INVALID_PARAMETER); +} + /** * @tc.name: TryHardwareEncodePictureTest001 * @tc.desc: test the function of TryHardwareEncodePicture @@ -2350,6 +2398,22 @@ HWTEST_F(ExtDecoderTest, HeifDecoderImpl_initTest002, TestSize.Level3) GTEST_LOG_(INFO) << "ExtDecoderTest: HeifDecoderImpl_initTest002 end"; } +/** + * @tc.name: HeifDecoderImpl_initTest003 + * @tc.desc: Verify HEIF decoder initialization fails with null stream and frameInfo. + * @tc.type: FUNC + */ +HWTEST_F(ExtDecoderTest, HeifDecoderImpl_initTest003, TestSize.Level3) +{ +#ifdef HEIF_HW_DECODE_ENABLE + HeifDecoderImpl decoder; + HeifStream *stream = nullptr; + HeifFrameInfo *frameInfo = nullptr; + bool ret = decoder.init(stream, frameInfo); + EXPECT_FALSE(ret); +#endif +} + /** * @tc.name: HeifDecoderImpl_CheckAuxiliaryMapTest001 * @tc.desc: Verify that CheckAuxiliaryMap call init when parser_ is nullptr. @@ -2408,6 +2472,22 @@ HWTEST_F(ExtDecoderTest, HeifDecoderImpl_CheckAuxiliaryMapTest002, TestSize.Leve GTEST_LOG_(INFO) << "ExtDecoderTest: HeifDecoderImpl_CheckAuxiliaryMapTest002 end"; } +/** + * @tc.name: HeifDecoderImpl_CheckAuxiliaryMapTest003 + * @tc.desc: Verify CheckAuxiliaryMap returns false when parser is null. + * @tc.type: FUNC + */ +HWTEST_F(ExtDecoderTest, HeifDecoderImpl_CheckAuxiliaryMapTest003, TestSize.Level3) +{ +#ifdef HEIF_HW_DECODE_ENABLE + HeifDecoderImpl decoder; + decoder.parser_ = nullptr; + AuxiliaryPictureType type = AuxiliaryPictureType::GAINMAP; + bool ret = decoder.CheckAuxiliaryMap(type); + EXPECT_FALSE(ret); +#endif +} + /** * @tc.name: HeifDecoderImpl_ReinitTest001 * @tc.desc: Verify that Reinit call init when primaryImage_ is nullptr. @@ -2709,5 +2789,36 @@ HWTEST_F(ExtDecoderTest, IsHeifValidCropTest001, TestSize.Level3) GTEST_LOG_(INFO) << "ExtDecoderTest: IsHeifValidCropTest001 end"; } +/** + * @tc.name: EncodePixelMapTest001 + * @tc.desc: Test HEIF encoding from a YCRCB_P010 format PixelMap and verify output image. + * @tc.type: FUNC + */ +HWTEST_F(ExtDecoderTest, EncodePixelMapTest001, TestSize.Level3) +{ + uint32_t errorCode = 0; + SourceOptions sourceOpts; + std::unique_ptr imageSource = ImageSource::CreateImageSource(IMAGE_HEIFHDR_SRC.c_str(), + sourceOpts, errorCode); + ASSERT_NE(imageSource, nullptr); + DecodeOptions opts; + opts.desiredPixelFormat = PixelFormat::YCRCB_P010; + std::shared_ptr pixelmap = imageSource->CreatePixelMap(opts, errorCode); + ASSERT_EQ(errorCode, OHOS::Media::SUCCESS); + ASSERT_NE(pixelmap, nullptr); + ImagePacker packer; + PackOption option; + option.format = "image/heif"; + option.needsPackProperties = true; + uint32_t startpc = packer.StartPacking(IMAGE_DEST, option); + ASSERT_EQ(startpc, OHOS::Media::SUCCESS); + uint32_t retAddImage = packer.AddImage(*pixelmap); + ASSERT_EQ(retAddImage, OHOS::Media::SUCCESS); + uint32_t retFinalizePacking = packer.FinalizePacking(); + ASSERT_EQ(retFinalizePacking, OHOS::Media::SUCCESS); + std::unique_ptr imageSourceDest = ImageSource::CreateImageSource(IMAGE_DEST, sourceOpts, errorCode); + EXPECT_EQ(errorCode, OHOS::Media::SUCCESS); + EXPECT_NE(imageSourceDest, nullptr); +} } } \ No newline at end of file diff --git a/frameworks/innerkitsimpl/test/unittest/post_proc_test.cpp b/frameworks/innerkitsimpl/test/unittest/post_proc_test.cpp index b7f3f5342..fbdb85008 100644 --- a/frameworks/innerkitsimpl/test/unittest/post_proc_test.cpp +++ b/frameworks/innerkitsimpl/test/unittest/post_proc_test.cpp @@ -16,14 +16,14 @@ #define protected public #include #include -#include "post_proc.h" #include "image_source.h" +#include "image_source_util.h" #include "image_type.h" #include "image_utils.h" #include "media_errors.h" -#include "pixel_map.h" -#include "image_source_util.h" #include "memory_manager.h" +#include "pixel_map.h" +#include "post_proc.h" using namespace testing::ext; using namespace OHOS::Media; @@ -34,7 +34,9 @@ static const std::string IMAGE_INPUT_JPEG_PATH = "/data/local/tmp/image/test.jpg static const std::string IMAGE_INPUT_JPG_PATH_EXACTSIZE = "/data/local/tmp/image/800-500.jpg"; static constexpr int32_t IMAGE_INPUT_JPG_WIDTH = 800; static constexpr int32_t IMAGE_INPUT_JPG_HEIGHT = 500; +static const int32_t NUM_1 = 1; static const int32_t NUM_2 = 2; +static const int32_t NUM_NEGATIVE_1 = -1; class PostProcTest : public testing::Test { public: @@ -1131,5 +1133,169 @@ HWTEST_F(PostProcTest, GetDstImageInfo001, TestSize.Level3) ASSERT_EQ(dstImageInfo.alphaType, AlphaType::IMAGE_ALPHA_TYPE_PREMUL); GTEST_LOG_(INFO) << "PostProcTest: GetDstImageInfo001 end"; } + +/** + * @tc.name: CenterScaleTest001 + * @tc.desc: Test CenterScale when targetWidth and targetHeight are valid or not. + * @tc.type: FUNC + */ +HWTEST_F(PostProcTest, CenterScaleTest001, TestSize.Level3) +{ + GTEST_LOG_(INFO) << "PostProcTest: CenterScaleTest001 start"; + Size size; + PixelMap pixelMap; + pixelMap.imageInfo_.size.height = NUM_1; + pixelMap.imageInfo_.size.width = NUM_1; + size.width = 0; + size.height = 0; + PostProc postProc; + + bool ret = postProc.CenterScale(size, pixelMap); + EXPECT_FALSE(ret); + + size.width = NUM_1; + size.height = 0; + ret = postProc.CenterScale(size, pixelMap); + EXPECT_FALSE(ret); + GTEST_LOG_(INFO) << "PostProcTest: CenterScaleTest001 end"; +} + +/** + * @tc.name: PixelConvertProcTest001 + * @tc.desc: Test PixelConvertProc when pixelBytes is 0. + * @tc.type: FUNC + */ +HWTEST_F(PostProcTest, PixelConvertProcTest001, TestSize.Level3) +{ + GTEST_LOG_(INFO) << "PostProcTest: PixelConvertProcTest001 start"; + ImageInfo dstImageInfo; + dstImageInfo.pixelFormat = PixelFormat::ARGB_8888; + ImageInfo srcImageInfo; + srcImageInfo.size.height = NUM_1; + srcImageInfo.size.width = NUM_1; + srcImageInfo.pixelFormat = PixelFormat::UNKNOWN; + PixelMap pixelMap; + PostProc postProc; + postProc.decodeOpts_.allocatorType = AllocatorType::SHARE_MEM_ALLOC; + + uint32_t ret = postProc.PixelConvertProc(dstImageInfo, pixelMap, srcImageInfo); + EXPECT_EQ(ret, ERR_IMAGE_CROP); + GTEST_LOG_(INFO) << "PostProcTest: PixelConvertProcTest001 end"; +} + +/** + * @tc.name: PixelConvertProcTest002 + * @tc.desc: Test PixelConvertProc when pixelMap SetImageInfo failed. + * @tc.type: FUNC + */ +HWTEST_F(PostProcTest, PixelConvertProcTest002, TestSize.Level3) +{ + GTEST_LOG_(INFO) << "PostProcTest: PixelConvertProcTest002 start"; + ImageInfo dstImageInfo; + dstImageInfo.pixelFormat = PixelFormat::ARGB_8888; + ImageInfo srcImageInfo; + srcImageInfo.size.height = NUM_1; + srcImageInfo.size.width = NUM_1; + srcImageInfo.pixelFormat = PixelFormat::ARGB_8888; + PixelMap pixelMap; + pixelMap.pixelBytes_ = 0; + PostProc postProc; + postProc.decodeOpts_.allocatorType = AllocatorType::SHARE_MEM_ALLOC; + + uint32_t ret = postProc.PixelConvertProc(dstImageInfo, pixelMap, srcImageInfo); + EXPECT_EQ(ret, SUCCESS); + GTEST_LOG_(INFO) << "PostProcTest: PixelConvertProcTest002 end"; +} + +/** + * @tc.name: ValidCropValueTest001 + * @tc.desc: Test ValidCropValue when reset the width and height of rect success or not. + * @tc.type: FUNC + */ +HWTEST_F(PostProcTest, ValidCropValueTest001, TestSize.Level3) +{ + GTEST_LOG_(INFO) << "PostProcTest: ValidCropValueTest001 start"; + Size size; + size.height = NUM_NEGATIVE_1; + size.width = NUM_NEGATIVE_1; + Rect rect; + rect.top = NUM_1; + rect.left = NUM_1; + + PostProc postProc; + CropValue ret = postProc.ValidCropValue(rect, size); + EXPECT_EQ(ret, CropValue::INVALID); + + size.height = NUM_1; + size.width = NUM_1; + rect.height = NUM_NEGATIVE_1; + rect.width = NUM_NEGATIVE_1; + ret = postProc.ValidCropValue(rect, size); + EXPECT_EQ(ret, CropValue::INVALID); + GTEST_LOG_(INFO) << "PostProcTest: ValidCropValueTest001 end"; +} + +/** + * @tc.name: GetScaleFormatTest001 + * @tc.desc: Test GetScaleFormat when didn't find formatPair in PIXEL_FORMAT_MAP. + * @tc.type: FUNC + */ +HWTEST_F(PostProcTest, GetScaleFormatTest001, TestSize.Level3) +{ + GTEST_LOG_(INFO) << "PostProcTest: GetScaleFormatTest001 start"; + PostProc postProc; + Size desiredSize; + PixelMap pixelMap; + pixelMap.imageInfo_.size.height = NUM_1; + pixelMap.imageInfo_.size.width = NUM_1; + pixelMap.data_ = new uint8_t; + pixelMap.imageInfo_.pixelFormat = PixelFormat::EXTERNAL_MAX; + AntiAliasingOption option = AntiAliasingOption::NONE; + bool ret = postProc.ScalePixelMapEx(desiredSize, pixelMap, option); + ASSERT_EQ(ret, false); + delete pixelMap.data_; + GTEST_LOG_(INFO) << "PostProcTest: GetScaleFormatTest001 end"; +} + +/** + * @tc.name: CheckPixelMapSLRTest001 + * @tc.desc: Test CheckPixelMapSLR when pixelFormat is not RGBA_8888 or desiredSize is same as srcSize or not. + * @tc.type: FUNC + */ +HWTEST_F(PostProcTest, CheckPixelMapSLRTest001, TestSize.Level3) +{ + GTEST_LOG_(INFO) << "PostProcTest: CheckPixelMapSLRTest001 start"; + Size desiredSize; + PixelMap pixelMap; + pixelMap.imageInfo_.pixelFormat = PixelFormat::ALPHA_8; + pixelMap.pixelBytes_ = 0; + PostProc postProc; + + bool ret = postProc.ScalePixelMapWithSLR(desiredSize, pixelMap, false); + EXPECT_FALSE(ret); + + pixelMap.imageInfo_.size.width = NUM_1; + pixelMap.imageInfo_.size.height = NUM_1; + desiredSize.width = NUM_1; + desiredSize.height = NUM_1; + ret = postProc.ScalePixelMapWithSLR(desiredSize, pixelMap, false); + EXPECT_FALSE(ret); + + desiredSize.width = NUM_2; + desiredSize.height = NUM_1; + ret = postProc.ScalePixelMapWithSLR(desiredSize, pixelMap, false); + EXPECT_FALSE(ret); + + desiredSize.width = NUM_1; + desiredSize.height = NUM_2; + ret = postProc.ScalePixelMapWithSLR(desiredSize, pixelMap, false); + EXPECT_FALSE(ret); + + desiredSize.width = NUM_2; + desiredSize.height = NUM_2; + ret = postProc.ScalePixelMapWithSLR(desiredSize, pixelMap, false); + EXPECT_FALSE(ret); + GTEST_LOG_(INFO) << "PostProcTest: CheckPixelMapSLRTest001 end"; +} } } \ No newline at end of file diff --git a/test/resource/image/ohos_test.xml b/test/resource/image/ohos_test.xml index 53ce5a85e..031cdbb78 100644 --- a/test/resource/image/ohos_test.xml +++ b/test/resource/image/ohos_test.xml @@ -116,6 +116,7 @@ -- Gitee