From 244b7887d88dbfa0ed5d7574d5c142274b5c6fc1 Mon Sep 17 00:00:00 2001 From: zhangguorong Date: Thu, 12 May 2022 17:56:06 +0800 Subject: [PATCH] feat:Add more unittest case and add some testcase to support BufferHandle Signed-off-by: zhangguorong --- codec/test/unittest/hdi_omx/BUILD.gn | 3 + .../unittest/hdi_omx/codec_hdi_omx_test.cpp | 635 +++++++++++++++--- 2 files changed, 551 insertions(+), 87 deletions(-) diff --git a/codec/test/unittest/hdi_omx/BUILD.gn b/codec/test/unittest/hdi_omx/BUILD.gn index 62689a587c..3505283554 100644 --- a/codec/test/unittest/hdi_omx/BUILD.gn +++ b/codec/test/unittest/hdi_omx/BUILD.gn @@ -22,6 +22,7 @@ ohos_unittest("codec_hdi_omx_test") { "//drivers/peripheral/codec/interfaces/include", "//drivers/peripheral/codec/hal/include", "//third_party/openmax/api/1.1.2", + "//drivers/peripheral/display/hdi_service/gralloc/include", ] sources = [ "codec_hdi_omx_test.cpp" ] @@ -45,6 +46,8 @@ ohos_unittest("codec_hdi_omx_test") { "device_driver_framework:libhdf_ipc_adapter", "device_driver_framework:libhdf_utils", "device_driver_framework:libhdi", + "display_device_driver:hdi_gralloc_client", + "graphic_chipsetsdk:buffer_handle", "hiviewdfx_hilog_native:libhilog", "utils_base:utils", ] diff --git a/codec/test/unittest/hdi_omx/codec_hdi_omx_test.cpp b/codec/test/unittest/hdi_omx/codec_hdi_omx_test.cpp index d9eaceb453..c42bcfa352 100644 --- a/codec/test/unittest/hdi_omx/codec_hdi_omx_test.cpp +++ b/codec/test/unittest/hdi_omx/codec_hdi_omx_test.cpp @@ -18,12 +18,14 @@ #include #include #include +#include +#include #include #include +#include #include #include #include - #include "codec_callback_type_stub.h" #include "codec_component_manager.h" #include "codec_component_type.h" @@ -36,6 +38,8 @@ using namespace testing::ext; namespace { struct CodecComponentManager *g_manager = nullptr; +struct CodecComponentType *g_component = nullptr; +struct CodecCallbackType *g_callback = nullptr; int32_t g_count = 0; #ifdef RK @@ -44,14 +48,15 @@ int32_t g_count = 0; constexpr int32_t INT_TO_STR_LEN = 32; constexpr int32_t ARRAY_TO_STR_LEN = 1000; - +constexpr uint32_t WIDTH = 640; +constexpr uint32_t HEIGHT = 480; +OHOS::HDI::Display::V1_0::IDisplayGralloc *g_gralloc = nullptr; #ifdef COMPONENT_NAME -struct CodecComponentType *g_component = nullptr; union OMX_VERSIONTYPE g_version; - constexpr int32_t BUFFER_SIZE = 640 * 480 * 3; constexpr int32_t ROLE_LEN = 240; constexpr int32_t FRAMERATE = 30 << 16; +constexpr uint32_t BUFFER_ID_ERROR = 65000; enum class PortIndex { PORT_INDEX_INPUT = 0, PORT_INDEX_OUTPUT = 1 }; template @@ -65,47 +70,70 @@ void InitParam(T ¶m) struct BufferInfo { std::shared_ptr omxBuffer; std::shared_ptr sharedMem; + BufferHandle *bufferHandle; BufferInfo() { omxBuffer = nullptr; sharedMem = nullptr; + bufferHandle = nullptr; } ~BufferInfo() { omxBuffer = nullptr; - if (sharedMem) { + if (sharedMem != nullptr) { sharedMem->UnmapAshmem(); sharedMem->CloseAshmem(); sharedMem = nullptr; } + if (bufferHandle != nullptr && g_gralloc != nullptr) { + g_gralloc->FreeMem(*bufferHandle); + bufferHandle = nullptr; + } } }; std::map> inputBuffers; std::map> outputBuffers; +static void InitCodecBufferWithAshMem(enum PortIndex portIndex, int bufferSize, shared_ptr omxBuffer, + shared_ptr sharedMem) +{ + omxBuffer->size = sizeof(OmxCodecBuffer); + omxBuffer->version = g_version; + omxBuffer->bufferType = BUFFER_TYPE_AVSHARE_MEM_FD; + omxBuffer->bufferLen = sizeof(int); + omxBuffer->buffer = (uint8_t *)(uintptr_t)sharedMem->GetAshmemFd(); + omxBuffer->allocLen = bufferSize; + omxBuffer->fenceFd = -1; + omxBuffer->pts = 0; + omxBuffer->flag = 0; + if (portIndex == PortIndex::PORT_INDEX_INPUT) { + omxBuffer->type = READ_ONLY_TYPE; + sharedMem->MapReadAndWriteAshmem(); + } else { + omxBuffer->type = READ_WRITE_TYPE; + sharedMem->MapReadOnlyAshmem(); + } +} static bool UseBufferOnPort(enum PortIndex portIndex, int bufferCount, int bufferSize) { for (int i = 0; i < bufferCount; i++) { std::shared_ptr omxBuffer = std::make_shared(); - omxBuffer->size = sizeof(OmxCodecBuffer); - omxBuffer->version = g_version; - omxBuffer->bufferType = BUFFER_TYPE_AVSHARE_MEM_FD; + if (omxBuffer == nullptr) { + HDF_LOGE("%{public}s omxBuffer is null", __func__); + return false; + } + int fd = OHOS::AshmemCreate(0, bufferSize); shared_ptr sharedMem = make_shared(fd, bufferSize); - omxBuffer->bufferLen = sizeof(int); - omxBuffer->buffer = (uint8_t*)(uintptr_t)fd; - omxBuffer->allocLen = bufferSize; - omxBuffer->fenceFd = -1; - omxBuffer->pts = 0; - omxBuffer->flag = 0; - - if (portIndex == PortIndex::PORT_INDEX_INPUT) { - omxBuffer->type = READ_ONLY_TYPE; - sharedMem->MapReadAndWriteAshmem(); - } else { - omxBuffer->type = READ_WRITE_TYPE; - sharedMem->MapReadOnlyAshmem(); + if (sharedMem == nullptr) { + HDF_LOGE("%{public}s sharedMem is null", __func__); + if (fd >= 0) { + close(fd); + fd = -1; + } + return false; } + InitCodecBufferWithAshMem(portIndex, bufferSize, omxBuffer, sharedMem); auto err = g_component->UseBuffer(g_component, (uint32_t)portIndex, omxBuffer.get()); if (err != HDF_SUCCESS) { HDF_LOGE("%{public}s failed to UseBuffer with portIndex[%{public}d]", __func__, portIndex); @@ -117,7 +145,6 @@ static bool UseBufferOnPort(enum PortIndex portIndex, int bufferCount, int buffe } omxBuffer->bufferLen = 0; HDF_LOGI("UseBuffer returned bufferID [%{public}d]", omxBuffer->bufferId); - std::shared_ptr bufferInfo = std::make_shared(); bufferInfo->omxBuffer = omxBuffer; bufferInfo->sharedMem = sharedMem; @@ -127,7 +154,6 @@ static bool UseBufferOnPort(enum PortIndex portIndex, int bufferCount, int buffe outputBuffers.emplace(std::make_pair(omxBuffer->bufferId, bufferInfo)); } } - return true; } #endif // COMPONENT_NAME @@ -138,9 +164,17 @@ public: static void TearDownTestCase() {} void SetUp() - {} + { + width_ = WIDTH; + height_ = HEIGHT; + g_gralloc = OHOS::HDI::Display::V1_0::IDisplayGralloc::Get(); + } void TearDown() {} + +public: + uint32_t width_; + uint32_t height_; }; static char arrayStr[ARRAY_TO_STR_LEN]; @@ -218,39 +252,68 @@ static void PrintCapability(CodecCompCapability *cap, int32_t index) HWTEST_F(CodecHdiOmxTest, HdfCodecHdiInitTest_001, TestSize.Level1) { - const int32_t componentCount = 9; g_manager = GetCodecComponentManager(); ASSERT_TRUE(g_manager != nullptr); + g_callback = CodecCallbackTypeStubGetInstance(); + ASSERT_TRUE(g_callback != nullptr); +} +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiGetComponentNumTest_001, TestSize.Level1) +{ + ASSERT_TRUE(g_manager != nullptr); g_count = g_manager->GetComponentNum(); - ASSERT_EQ(g_count, componentCount); + ASSERT_TRUE(g_count > 0); } -HWTEST_F(CodecHdiOmxTest, HdfCodecGetCapabilityListTest_001, TestSize.Level1) +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiGetCapabilityListTest_001, TestSize.Level1) { ASSERT_TRUE(g_count > 0); ASSERT_TRUE(g_manager != nullptr); CodecCompCapability *capList = (CodecCompCapability *)OsalMemAlloc(sizeof(CodecCompCapability) * g_count); + ASSERT_TRUE(capList != nullptr); g_manager->GetComponentCapabilityList(capList, g_count); for (int32_t i = 0; i < g_count; i++) { PrintCapability(&capList[i], i); } + OsalMemFree(capList); + capList = nullptr; +} + +// Test CreateComponent +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiCreateComponentTest_001, TestSize.Level1) +{ + ASSERT_TRUE(g_manager != nullptr); + ASSERT_TRUE(g_callback != nullptr); + char name[] = "test"; + int32_t ret = g_manager->CreateComponent(&g_component, (char *)name, nullptr, 0, g_callback); + ASSERT_NE(ret, HDF_SUCCESS); + ASSERT_TRUE(g_component == nullptr); +} + +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiCreateComponentTest_002, TestSize.Level1) +{ + ASSERT_TRUE(g_manager != nullptr); + ASSERT_TRUE(g_callback != nullptr); + int32_t ret = g_manager->CreateComponent(&g_component, nullptr, nullptr, 0, g_callback); + ASSERT_NE(ret, HDF_SUCCESS); + ASSERT_TRUE(g_component == nullptr); } #ifdef COMPONENT_NAME -HWTEST_F(CodecHdiOmxTest, HdfCodecCreateComponentTest_001, TestSize.Level1) +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiCreateComponentTest_003, TestSize.Level1) { const int32_t testingAppData = 33; - CodecCallbackType *callback = CodecCallbackTypeStubGetInstance(); + ASSERT_TRUE(g_manager != nullptr); + ASSERT_TRUE(g_callback != nullptr); int32_t appData = testingAppData; int32_t ret = g_manager->CreateComponent(&g_component, const_cast(COMPONENT_NAME), &appData, - sizeof(appData), callback); - HDF_LOGE("%{public}s: after CreateComponent!", __func__); + sizeof(appData), g_callback); ASSERT_EQ(ret, HDF_SUCCESS); ASSERT_TRUE(g_component != nullptr); } -HWTEST_F(CodecHdiOmxTest, HdfCodecGetVersionTest_001, TestSize.Level1) +// Test GetComponentVersion +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiGetVersionTest_001, TestSize.Level1) { ASSERT_TRUE(g_component != nullptr); struct CompVerInfo verInfo; @@ -258,10 +321,24 @@ HWTEST_F(CodecHdiOmxTest, HdfCodecGetVersionTest_001, TestSize.Level1) g_version = verInfo.compVersion; ASSERT_EQ(ret, HDF_SUCCESS); ASSERT_STREQ(COMPONENT_NAME, verInfo.compName); - HDF_LOGE("%{public}s: verInfo.compName is %{public}s!", __func__, verInfo.compName); } -HWTEST_F(CodecHdiOmxTest, HdfCodecGetParameterTest_001, TestSize.Level1) +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiGetVersionTest_002, TestSize.Level1) +{ + ASSERT_TRUE(g_component != nullptr); + int32_t ret = g_component->GetComponentVersion(g_component, nullptr); + ASSERT_NE(ret, HDF_SUCCESS); +} + +// Test GetParameter +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiGetParameterTest_003, TestSize.Level1) +{ + ASSERT_TRUE(g_component != nullptr); + auto ret = g_component->GetParameter(g_component, OMX_IndexParamVideoPortFormat, nullptr, 0); + ASSERT_NE(ret, HDF_SUCCESS); +} + +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiGetParameterTest_004, TestSize.Level1) { ASSERT_TRUE(g_component != nullptr); OMX_VIDEO_PARAM_PORTFORMATTYPE param; @@ -273,8 +350,7 @@ HWTEST_F(CodecHdiOmxTest, HdfCodecGetParameterTest_001, TestSize.Level1) ASSERT_EQ(ret, HDF_SUCCESS); } -// GetParameter with no version -HWTEST_F(CodecHdiOmxTest, HdfCodecGetParameterTest_002, TestSize.Level1) +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiGetParameterTest_005, TestSize.Level1) { ASSERT_TRUE(g_component != nullptr); OMX_VIDEO_PARAM_PORTFORMATTYPE param; @@ -286,7 +362,30 @@ HWTEST_F(CodecHdiOmxTest, HdfCodecGetParameterTest_002, TestSize.Level1) ASSERT_NE(ret, HDF_SUCCESS); } -HWTEST_F(CodecHdiOmxTest, HdfCodecSetParameterTest_001, TestSize.Level1) +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiGetParameterTest_006, TestSize.Level1) +{ + ASSERT_TRUE(g_component != nullptr); + OMX_VIDEO_CONFIG_BITRATETYPE param; + InitParam(param); + param.nPortIndex = (uint32_t)PortIndex::PORT_INDEX_INPUT; + auto ret = g_component->GetParameter(g_component, OMX_IndexParamVideoPortFormat, reinterpret_cast(¶m), + sizeof(param)); + ASSERT_NE(ret, HDF_SUCCESS); +} + +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiGetParameterTest_007, TestSize.Level1) +{ + ASSERT_TRUE(g_component != nullptr); + OMX_VIDEO_CONFIG_BITRATETYPE param; + InitParam(param); + param.nPortIndex = (uint32_t)PortIndex::PORT_INDEX_INPUT; + auto ret = g_component->GetParameter(g_component, OMX_IndexVideoStartUnused, reinterpret_cast(¶m), + sizeof(param)); + ASSERT_NE(ret, HDF_SUCCESS); +} + +// SetParameter with no version +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiSetParameterTest_001, TestSize.Level1) { ASSERT_TRUE(g_component != nullptr); OMX_VIDEO_PARAM_PORTFORMATTYPE param; @@ -297,8 +396,7 @@ HWTEST_F(CodecHdiOmxTest, HdfCodecSetParameterTest_001, TestSize.Level1) ASSERT_EQ(ret, HDF_SUCCESS); } -// SetParameter with no version -HWTEST_F(CodecHdiOmxTest, HdfCodecSetParameterTest_002, TestSize.Level1) +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiSetParameterTest_002, TestSize.Level1) { ASSERT_TRUE(g_component != nullptr); OMX_VIDEO_PARAM_PORTFORMATTYPE param; @@ -309,7 +407,37 @@ HWTEST_F(CodecHdiOmxTest, HdfCodecSetParameterTest_002, TestSize.Level1) ASSERT_NE(ret, HDF_SUCCESS); } -HWTEST_F(CodecHdiOmxTest, HdfCodecGetConfigTest_001, TestSize.Level1) +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiSetParameterTest_003, TestSize.Level1) +{ + ASSERT_TRUE(g_component != nullptr); + int32_t ret = g_component->SetParameter(g_component, OMX_IndexParamVideoPortFormat, nullptr, 0); + ASSERT_NE(ret, HDF_SUCCESS); +} + +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiSetParameterTest_004, TestSize.Level1) +{ + ASSERT_TRUE(g_component != nullptr); + OMX_VIDEO_CONFIG_BITRATETYPE param; + InitParam(param); + param.nPortIndex = (uint32_t)PortIndex::PORT_INDEX_INPUT; + int32_t ret = g_component->SetParameter(g_component, OMX_IndexParamVideoPortFormat, + reinterpret_cast(¶m), sizeof(param)); + ASSERT_NE(ret, HDF_SUCCESS); +} + +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiSetParameterTest_005, TestSize.Level1) +{ + ASSERT_TRUE(g_component != nullptr); + OMX_VIDEO_PARAM_PORTFORMATTYPE param; + InitParam(param); + param.nPortIndex = (uint32_t)PortIndex::PORT_INDEX_INPUT; + int32_t ret = g_component->SetParameter(g_component, OMX_IndexVideoStartUnused, reinterpret_cast(¶m), + sizeof(param)); + ASSERT_NE(ret, HDF_SUCCESS); +} + +// Test GetConfig +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiGetConfigTest_001, TestSize.Level1) { ASSERT_TRUE(g_component != nullptr); OMX_VIDEO_CONFIG_BITRATETYPE param; @@ -320,7 +448,37 @@ HWTEST_F(CodecHdiOmxTest, HdfCodecGetConfigTest_001, TestSize.Level1) ASSERT_EQ(ret, HDF_SUCCESS); } -HWTEST_F(CodecHdiOmxTest, HdfCodecSetConfigTest_001, TestSize.Level1) +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiGetConfigTest_002, TestSize.Level1) +{ + ASSERT_TRUE(g_component != nullptr); + OMX_VIDEO_CONFIG_BITRATETYPE param; + InitParam(param); + param.nPortIndex = (uint32_t)PortIndex::PORT_INDEX_INPUT; + int32_t ret = g_component->GetConfig(g_component, OMX_IndexConfigVideoBitrate, reinterpret_cast(¶m), + sizeof(param)); + ASSERT_NE(ret, HDF_SUCCESS); +} + +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiGetConfigTest_003, TestSize.Level1) +{ + ASSERT_TRUE(g_component != nullptr); + int32_t ret = g_component->GetConfig(g_component, OMX_IndexConfigVideoBitrate, nullptr, 0); + ASSERT_NE(ret, HDF_SUCCESS); +} + +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiGetConfigTest_004, TestSize.Level1) +{ + ASSERT_TRUE(g_component != nullptr); + OMX_VIDEO_CONFIG_BITRATETYPE param; + InitParam(param); + param.nPortIndex = (uint32_t)PortIndex::PORT_INDEX_OUTPUT; + int32_t ret = g_component->GetConfig(g_component, OMX_IndexVideoStartUnused, reinterpret_cast(¶m), + sizeof(param)); + ASSERT_NE(ret, HDF_SUCCESS); +} + +// Test SetConfig +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiSetConfigTest_001, TestSize.Level1) { ASSERT_TRUE(g_component != nullptr); OMX_VIDEO_CONFIG_BITRATETYPE param; @@ -332,32 +490,38 @@ HWTEST_F(CodecHdiOmxTest, HdfCodecSetConfigTest_001, TestSize.Level1) ASSERT_EQ(ret, HDF_SUCCESS); } -// GetConfig error -HWTEST_F(CodecHdiOmxTest, HdfCodecGetConfigTest_002, TestSize.Level1) +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiSetConfigTest_002, TestSize.Level1) { ASSERT_TRUE(g_component != nullptr); OMX_VIDEO_CONFIG_BITRATETYPE param; InitParam(param); param.nPortIndex = (uint32_t)PortIndex::PORT_INDEX_INPUT; - int32_t ret = g_component->GetConfig(g_component, OMX_IndexConfigVideoBitrate, reinterpret_cast(¶m), + param.nEncodeBitrate = FRAMERATE; + int32_t ret = g_component->SetConfig(g_component, OMX_IndexConfigVideoBitrate, reinterpret_cast(¶m), sizeof(param)); ASSERT_NE(ret, HDF_SUCCESS); } -// SetConfig with no version -HWTEST_F(CodecHdiOmxTest, HdfCodecSetConfigTest_002, TestSize.Level1) +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiSetConfigTest_003, TestSize.Level1) +{ + ASSERT_TRUE(g_component != nullptr); + int32_t ret = g_component->SetConfig(g_component, OMX_IndexConfigVideoBitrate, nullptr, 0); + ASSERT_NE(ret, HDF_SUCCESS); +} + +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiSetConfigTest_004, TestSize.Level1) { ASSERT_TRUE(g_component != nullptr); OMX_VIDEO_CONFIG_BITRATETYPE param; InitParam(param); - param.nPortIndex = (uint32_t)PortIndex::PORT_INDEX_INPUT; - param.nEncodeBitrate = FRAMERATE; - int32_t ret = g_component->SetConfig(g_component, OMX_IndexConfigVideoBitrate, reinterpret_cast(¶m), + param.nPortIndex = (uint32_t)PortIndex::PORT_INDEX_OUTPUT; + int32_t ret = g_component->SetConfig(g_component, OMX_IndexVideoStartUnused, reinterpret_cast(¶m), sizeof(param)); ASSERT_NE(ret, HDF_SUCCESS); } -HWTEST_F(CodecHdiOmxTest, HdfCodecGetExtensionIndexTest_001, TestSize.Level1) +// Test GetExtensionIndex +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiGetExtensionIndexTest_001, TestSize.Level1) { ASSERT_TRUE(g_component != nullptr); OMX_INDEXTYPE indexType; @@ -366,7 +530,33 @@ HWTEST_F(CodecHdiOmxTest, HdfCodecGetExtensionIndexTest_001, TestSize.Level1) ASSERT_EQ(ret, HDF_SUCCESS); } -HWTEST_F(CodecHdiOmxTest, HdfCodecGetStateTest_001, TestSize.Level1) +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiGetExtensionIndexTest_002, TestSize.Level1) +{ + ASSERT_TRUE(g_component != nullptr); + OMX_INDEXTYPE indexType; + int32_t ret = + g_component->GetExtensionIndex(g_component, "OMX.Topaz.index.param.extended_video", (uint32_t *)&indexType); + ASSERT_EQ(ret, HDF_SUCCESS); +} + +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiGetExtensionIndexTest_003, TestSize.Level1) +{ + ASSERT_TRUE(g_component != nullptr); + OMX_INDEXTYPE indexType; + int32_t ret = + g_component->GetExtensionIndex(g_component, "OMX.Topaz.index.param.extended_test", (uint32_t *)&indexType); + ASSERT_NE(ret, HDF_SUCCESS); +} + +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiGetExtensionIndexTest_004, TestSize.Level1) +{ + ASSERT_TRUE(g_component != nullptr); + int32_t ret = g_component->GetExtensionIndex(g_component, "OMX.Topaz.index.param.extended_video", nullptr); + ASSERT_NE(ret, HDF_SUCCESS); +} + +// Test GetState +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiGetStateTest_001, TestSize.Level1) { ASSERT_TRUE(g_component != nullptr); OMX_STATETYPE state; @@ -375,7 +565,15 @@ HWTEST_F(CodecHdiOmxTest, HdfCodecGetStateTest_001, TestSize.Level1) ASSERT_EQ(ret, HDF_SUCCESS); } -HWTEST_F(CodecHdiOmxTest, HdfCodecTunnelRequestTestTest_001, TestSize.Level1) +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiGetStateTest_002, TestSize.Level1) +{ + ASSERT_TRUE(g_component != nullptr); + int32_t ret = g_component->GetState(g_component, nullptr); + ASSERT_NE(ret, HDF_SUCCESS); +} + +// Test ComponentTunnelRequest +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiTunnelRequestTest_001, TestSize.Level1) { ASSERT_TRUE(g_component != nullptr); const int32_t tunneledComp = 1002; @@ -388,8 +586,15 @@ HWTEST_F(CodecHdiOmxTest, HdfCodecTunnelRequestTestTest_001, TestSize.Level1) ASSERT_NE(ret, HDF_SUCCESS); } -// send command to Idle buffer allocate and usebuffer -HWTEST_F(CodecHdiOmxTest, HdfCodecToIdleTest_001, TestSize.Level1) +// Test SendCommand +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiLoadedToExecutingTest_001, TestSize.Level1) +{ + ASSERT_TRUE(g_component != nullptr); + int32_t ret = g_component->SendCommand(g_component, OMX_CommandStateSet, OMX_StateExecuting, nullptr, 0); + ASSERT_EQ(ret, HDF_SUCCESS); +} + +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiLoadedToIdleTest_001, TestSize.Level1) { ASSERT_TRUE(g_component != nullptr); int32_t ret = g_component->SendCommand(g_component, OMX_CommandStateSet, OMX_StateIdle, nullptr, 0); @@ -399,9 +604,126 @@ HWTEST_F(CodecHdiOmxTest, HdfCodecToIdleTest_001, TestSize.Level1) ret = g_component->GetState(g_component, &state); ASSERT_EQ(ret, HDF_SUCCESS); } +struct OmxCodecBuffer allocBuffer; +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiAllocateBufferTest_001, TestSize.Level1) +{ + ASSERT_TRUE(g_component != nullptr); + allocBuffer.bufferType = BUFFER_TYPE_INVALID; + allocBuffer.fenceFd = -1; + allocBuffer.version = g_version; + allocBuffer.allocLen = BUFFER_SIZE; + allocBuffer.buffer = 0; + allocBuffer.bufferLen = 0; + allocBuffer.pts = 0; + allocBuffer.flag = 0; + allocBuffer.type = READ_ONLY_TYPE; + int32_t ret = g_component->AllocateBuffer(g_component, (uint32_t)PortIndex::PORT_INDEX_INPUT, &allocBuffer); + ASSERT_NE(ret, HDF_SUCCESS); +} + +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiAllocateBufferTest_002, TestSize.Level1) +{ + ASSERT_TRUE(g_component != nullptr); + allocBuffer.bufferType = BUFFER_TYPE_VIRTUAL_ADDR; + int32_t ret = g_component->AllocateBuffer(g_component, (uint32_t)PortIndex::PORT_INDEX_INPUT, &allocBuffer); + ASSERT_NE(ret, HDF_SUCCESS); +} + +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiAllocateBufferTest_003, TestSize.Level1) +{ + ASSERT_TRUE(g_component != nullptr); + allocBuffer.bufferType = BUFFER_TYPE_INVALID; + int32_t ret = g_component->AllocateBuffer(g_component, (uint32_t)PortIndex::PORT_INDEX_OUTPUT, &allocBuffer); + ASSERT_NE(ret, HDF_SUCCESS); +} + +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiAllocateBufferTest_004, TestSize.Level1) +{ + ASSERT_TRUE(g_component != nullptr); + allocBuffer.bufferType = BUFFER_TYPE_VIRTUAL_ADDR; + int32_t ret = g_component->AllocateBuffer(g_component, (uint32_t)PortIndex::PORT_INDEX_OUTPUT, &allocBuffer); + ASSERT_NE(ret, HDF_SUCCESS); +} + +// Test UseBuffer +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiUseBufferTest_001, TestSize.Level1) +{ + ASSERT_TRUE(g_component != nullptr); + std::shared_ptr omxBuffer = std::make_shared(); + ASSERT_TRUE(omxBuffer != nullptr); + omxBuffer->size = sizeof(OmxCodecBuffer); + omxBuffer->version = g_version; + omxBuffer->bufferType = BUFFER_TYPE_INVALID; + omxBuffer->bufferLen = 0; + omxBuffer->buffer = nullptr; + omxBuffer->allocLen = 0; + omxBuffer->fenceFd = -1; + omxBuffer->pts = 0; + omxBuffer->flag = 0; + + auto err = g_component->UseBuffer(g_component, (uint32_t)PortIndex::PORT_INDEX_INPUT, omxBuffer.get()); + ASSERT_NE(err, HDF_SUCCESS); +} + +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiUseBufferTest_002, TestSize.Level1) +{ + ASSERT_TRUE(g_component != nullptr); + std::shared_ptr omxBuffer = std::make_shared(); + ASSERT_TRUE(omxBuffer != nullptr); + omxBuffer->size = sizeof(OmxCodecBuffer); + omxBuffer->version = g_version; + omxBuffer->bufferType = BUFFER_TYPE_INVALID; + omxBuffer->bufferLen = 0; + omxBuffer->buffer = nullptr; + omxBuffer->allocLen = 0; + omxBuffer->fenceFd = -1; + omxBuffer->pts = 0; + omxBuffer->flag = 0; + + auto err = g_component->UseBuffer(g_component, (uint32_t)PortIndex::PORT_INDEX_OUTPUT, omxBuffer.get()); + ASSERT_NE(err, HDF_SUCCESS); +} + +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiUseBufferTest_003, TestSize.Level1) +{ + ASSERT_TRUE(g_component != nullptr); + std::shared_ptr omxBuffer = std::make_shared(); + ASSERT_TRUE(omxBuffer != nullptr); + omxBuffer->size = sizeof(OmxCodecBuffer); + omxBuffer->version = g_version; + omxBuffer->bufferType = BUFFER_TYPE_VIRTUAL_ADDR; + omxBuffer->bufferLen = 0; + omxBuffer->buffer = nullptr; + omxBuffer->allocLen = 0; + omxBuffer->fenceFd = -1; + omxBuffer->pts = 0; + omxBuffer->flag = 0; + + auto err = g_component->UseBuffer(g_component, (uint32_t)PortIndex::PORT_INDEX_INPUT, omxBuffer.get()); + ASSERT_NE(err, HDF_SUCCESS); +} + +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiUseBufferTest_004, TestSize.Level1) +{ + ASSERT_TRUE(g_component != nullptr); + std::shared_ptr omxBuffer = std::make_shared(); + ASSERT_TRUE(omxBuffer != nullptr); + omxBuffer->size = sizeof(OmxCodecBuffer); + omxBuffer->version = g_version; + omxBuffer->bufferType = BUFFER_TYPE_VIRTUAL_ADDR; + omxBuffer->bufferLen = 0; + omxBuffer->buffer = nullptr; + omxBuffer->allocLen = 0; + omxBuffer->fenceFd = -1; + omxBuffer->pts = 0; + omxBuffer->flag = 0; + + auto err = g_component->UseBuffer(g_component, (uint32_t)PortIndex::PORT_INDEX_OUTPUT, omxBuffer.get()); + ASSERT_NE(err, HDF_SUCCESS); +} // Use buffer on input index -HWTEST_F(CodecHdiOmxTest, HdfCodecUseBufferTest_001, TestSize.Level1) +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiUseBufferTest_005, TestSize.Level1) { ASSERT_TRUE(g_component != nullptr); OMX_PARAM_PORTDEFINITIONTYPE param; @@ -412,12 +734,53 @@ HWTEST_F(CodecHdiOmxTest, HdfCodecUseBufferTest_001, TestSize.Level1) int bufferSize = param.nBufferSize; int bufferCount = param.nBufferCountActual; - bool ret = UseBufferOnPort(PortIndex::PORT_INDEX_INPUT, bufferCount, bufferSize); + bool ret = UseBufferOnPort(PortIndex::PORT_INDEX_INPUT, bufferCount - 1, bufferSize); ASSERT_TRUE(ret); } +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiUseBufferTest_006, TestSize.Level1) +{ + ASSERT_TRUE(g_component != nullptr); + AllocInfo alloc = {.width = this->width_, + .height = this->height_, + .usage = HBM_USE_CPU_READ | HBM_USE_CPU_WRITE | HBM_USE_MEM_DMA, + .format = PIXEL_FMT_YCBCR_420_SP}; + ASSERT_TRUE(g_gralloc != nullptr); + BufferHandle *bufferHandle = nullptr; + auto err = g_gralloc->AllocMem(alloc, bufferHandle); + ASSERT_EQ(err, DISPLAY_SUCCESS); + std::shared_ptr omxBuffer = std::make_shared(); + ASSERT_TRUE(omxBuffer != nullptr); + size_t handleSize = + sizeof(BufferHandle) + (sizeof(int32_t) * (bufferHandle->reserveFds + bufferHandle->reserveInts)); + omxBuffer->size = sizeof(OmxCodecBuffer); + omxBuffer->version = g_version; + omxBuffer->bufferType = BUFFER_TYPE_HANDLE; + + omxBuffer->bufferLen = handleSize; + omxBuffer->buffer = reinterpret_cast(bufferHandle); + omxBuffer->allocLen = handleSize; + omxBuffer->fenceFd = -1; + omxBuffer->pts = 0; + omxBuffer->flag = 0; + + err = g_component->UseBuffer(g_component, (uint32_t)PortIndex::PORT_INDEX_INPUT, omxBuffer.get()); + if (err != HDF_SUCCESS) { + HDF_LOGE("%{public}s failed to UseBuffer with input port", __func__); + omxBuffer = nullptr; + } + ASSERT_EQ(err, HDF_SUCCESS); + omxBuffer->bufferLen = 0; + + std::shared_ptr bufferInfo = std::make_shared(); + ASSERT_TRUE(bufferInfo != nullptr); + bufferInfo->omxBuffer = omxBuffer; + bufferInfo->bufferHandle = bufferHandle; + inputBuffers.emplace(std::make_pair(omxBuffer->bufferId, bufferInfo)); +} + // Use Buffer on output index -HWTEST_F(CodecHdiOmxTest, HdfCodecUseBufferTest_002, TestSize.Level1) +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiUseBufferTest_007, TestSize.Level1) { ASSERT_TRUE(g_component != nullptr); OMX_PARAM_PORTDEFINITIONTYPE param; @@ -428,12 +791,42 @@ HWTEST_F(CodecHdiOmxTest, HdfCodecUseBufferTest_002, TestSize.Level1) int bufferSize = param.nBufferSize; int bufferCount = param.nBufferCountActual; - bool ret = UseBufferOnPort(PortIndex::PORT_INDEX_OUTPUT, bufferCount, bufferSize); + bool ret = UseBufferOnPort(PortIndex::PORT_INDEX_OUTPUT, bufferCount - 1, bufferSize); ASSERT_TRUE(ret); } +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiUseBufferTest_008, TestSize.Level1) +{ + ASSERT_TRUE(g_component != nullptr); + std::shared_ptr omxBuffer = std::make_shared(); + ASSERT_TRUE(omxBuffer != nullptr); + omxBuffer->size = sizeof(OmxCodecBuffer); + omxBuffer->version = g_version; + omxBuffer->bufferType = BUFFER_TYPE_DYNAMIC_HANDLE; + + omxBuffer->bufferLen = 0; + omxBuffer->buffer = nullptr; + omxBuffer->allocLen = 0; + omxBuffer->fenceFd = -1; + omxBuffer->pts = 0; + omxBuffer->flag = 0; + + auto err = g_component->UseBuffer(g_component, (uint32_t)PortIndex::PORT_INDEX_OUTPUT, omxBuffer.get()); + if (err != HDF_SUCCESS) { + HDF_LOGE("%{public}s failed to UseBuffer with input port", __func__); + omxBuffer = nullptr; + } + ASSERT_EQ(err, HDF_SUCCESS); + omxBuffer->bufferLen = 0; + + std::shared_ptr bufferInfo = std::make_shared(); + ASSERT_TRUE(bufferInfo != nullptr); + bufferInfo->omxBuffer = omxBuffer; + outputBuffers.emplace(std::make_pair(omxBuffer->bufferId, bufferInfo)); +} + // Use buffer on input index error when OMX_ErrorInsufficientResources -HWTEST_F(CodecHdiOmxTest, HdfCodecUseBufferTest_003, TestSize.Level1) +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiUseBufferTest_009, TestSize.Level1) { ASSERT_TRUE(g_component != nullptr); OMX_PARAM_PORTDEFINITIONTYPE param; @@ -448,7 +841,7 @@ HWTEST_F(CodecHdiOmxTest, HdfCodecUseBufferTest_003, TestSize.Level1) ASSERT_FALSE(ret); } // Use buffer on output index error when OMX_ErrorInsufficientResources -HWTEST_F(CodecHdiOmxTest, HdfCodecUseBufferTest_004, TestSize.Level1) +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiUseBufferTest_010, TestSize.Level1) { ASSERT_TRUE(g_component != nullptr); OMX_PARAM_PORTDEFINITIONTYPE param; @@ -463,28 +856,25 @@ HWTEST_F(CodecHdiOmxTest, HdfCodecUseBufferTest_004, TestSize.Level1) ASSERT_FALSE(ret); } -struct OmxCodecBuffer allocBuffer; -HWTEST_F(CodecHdiOmxTest, HdfCodecAllocateBufferTest_001, TestSize.Level1) +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiAllocateBufferTest_005, TestSize.Level1) { ASSERT_TRUE(g_component != nullptr); - // buffer is full - allocBuffer.fenceFd = -1; - allocBuffer.version = g_version; allocBuffer.bufferType = BUFFER_TYPE_AVSHARE_MEM_FD; - allocBuffer.allocLen = BUFFER_SIZE; - allocBuffer.buffer = 0; - allocBuffer.bufferLen = 0; - allocBuffer.pts = 0; - allocBuffer.flag = 0; - allocBuffer.type = READ_ONLY_TYPE; int32_t ret = g_component->AllocateBuffer(g_component, (uint32_t)PortIndex::PORT_INDEX_INPUT, &allocBuffer); ASSERT_NE(ret, HDF_SUCCESS); } -HWTEST_F(CodecHdiOmxTest, HdfCodecUseEglImageTest_001, TestSize.Level1) +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiAllocateBufferTest_006, TestSize.Level1) +{ + ASSERT_TRUE(g_component != nullptr); + allocBuffer.bufferType = BUFFER_TYPE_AVSHARE_MEM_FD; + int32_t ret = g_component->AllocateBuffer(g_component, (uint32_t)PortIndex::PORT_INDEX_OUTPUT, &allocBuffer); + ASSERT_NE(ret, HDF_SUCCESS); +} + +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiUseEglImageTest_001, TestSize.Level1) { ASSERT_TRUE(g_component != nullptr); - // buffer is full struct OmxCodecBuffer buffer; buffer.fenceFd = -1; buffer.version = g_version; @@ -496,13 +886,14 @@ HWTEST_F(CodecHdiOmxTest, HdfCodecUseEglImageTest_001, TestSize.Level1) buffer.flag = 0; buffer.type = READ_ONLY_TYPE; auto eglImage = std::make_unique(BUFFER_SIZE); + ASSERT_TRUE(eglImage != nullptr); int32_t ret = g_component->UseEglImage(g_component, &buffer, (uint32_t)PortIndex::PORT_INDEX_INPUT, eglImage.get(), BUFFER_SIZE); ASSERT_NE(ret, HDF_SUCCESS); eglImage = nullptr; } -HWTEST_F(CodecHdiOmxTest, HdfCodecWaitStateTest_001, TestSize.Level1) +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiWaitStateTest_001, TestSize.Level1) { ASSERT_TRUE(g_component != nullptr); // wait for Idle status @@ -514,7 +905,7 @@ HWTEST_F(CodecHdiOmxTest, HdfCodecWaitStateTest_001, TestSize.Level1) } while (state != OMX_StateIdle); } -HWTEST_F(CodecHdiOmxTest, HdfCodecFillThisBufferTest_001, TestSize.Level1) +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiFillThisBufferTest_001, TestSize.Level1) { ASSERT_TRUE(g_component != nullptr); int32_t ret = g_component->SendCommand(g_component, OMX_CommandStateSet, OMX_StateExecuting, nullptr, 0); @@ -534,7 +925,21 @@ HWTEST_F(CodecHdiOmxTest, HdfCodecFillThisBufferTest_001, TestSize.Level1) } } -HWTEST_F(CodecHdiOmxTest, HdfCodecEmptyThisBufferTest_001, TestSize.Level1) +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiFillThisBufferTest_002, TestSize.Level1) +{ + ASSERT_TRUE(g_component != nullptr); + auto iter = outputBuffers.begin(); + if (iter != outputBuffers.end()) { + auto omxBuffer = iter->second->omxBuffer; + auto tempId = omxBuffer->bufferId; + omxBuffer->bufferId = BUFFER_ID_ERROR; + int32_t ret = g_component->FillThisBuffer(g_component, omxBuffer.get()); + ASSERT_NE(ret, HDF_SUCCESS); + omxBuffer->bufferId = tempId; + } +} + +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiEmptyThisBufferTest_001, TestSize.Level1) { ASSERT_TRUE(g_component != nullptr); auto iter = inputBuffers.begin(); @@ -544,20 +949,38 @@ HWTEST_F(CodecHdiOmxTest, HdfCodecEmptyThisBufferTest_001, TestSize.Level1) } } -HWTEST_F(CodecHdiOmxTest, HdfCodecSetCallbackTest_001, TestSize.Level1) +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiEmptyThisBufferTest_002, TestSize.Level1) +{ + ASSERT_TRUE(g_component != nullptr); + auto iter = inputBuffers.begin(); + if (iter != inputBuffers.end()) { + auto omxBuffer = iter->second->omxBuffer; + auto tempId = omxBuffer->bufferId; + omxBuffer->bufferId = BUFFER_ID_ERROR; + int32_t ret = g_component->EmptyThisBuffer(g_component, iter->second->omxBuffer.get()); + ASSERT_NE(ret, HDF_SUCCESS); + omxBuffer->bufferId = tempId; + } +} + +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiSetCallbackTest_001, TestSize.Level1) { ASSERT_TRUE(g_component != nullptr); const int32_t appDataLen = 10; - CodecCallbackType *callback = CodecCallbackTypeStubGetInstance(); + if (g_callback != nullptr) { + CodecCallbackTypeStubRelease(g_callback); + } + g_callback = CodecCallbackTypeStubGetInstance(); + ASSERT_TRUE(g_callback != nullptr); int8_t appData[appDataLen]; for (int8_t i = 0; i < appDataLen; i++) { appData[i] = i; } - int32_t ret = g_component->SetCallbacks(g_component, callback, appData, (uint32_t)appDataLen); + int32_t ret = g_component->SetCallbacks(g_component, g_callback, appData, (uint32_t)appDataLen); ASSERT_EQ(ret, HDF_SUCCESS); } -HWTEST_F(CodecHdiOmxTest, HdfCodecRoleEnumTest_001, TestSize.Level1) +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiRoleEnumTest_001, TestSize.Level1) { ASSERT_TRUE(g_component != nullptr); uint8_t role[ROLE_LEN] = {0}; @@ -566,7 +989,7 @@ HWTEST_F(CodecHdiOmxTest, HdfCodecRoleEnumTest_001, TestSize.Level1) } // Executing to Idle -HWTEST_F(CodecHdiOmxTest, HdfCodecExecutingToIdleTest_001, TestSize.Level1) +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiExecutingToIdleTest_001, TestSize.Level1) { ASSERT_TRUE(g_component != nullptr); int32_t ret = g_component->SendCommand(g_component, OMX_CommandStateSet, OMX_StateIdle, nullptr, 0); @@ -574,7 +997,21 @@ HWTEST_F(CodecHdiOmxTest, HdfCodecExecutingToIdleTest_001, TestSize.Level1) } // Release input buffer -HWTEST_F(CodecHdiOmxTest, HdfCodecFreeBufferTest_001, TestSize.Level1) +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiFreeBufferTest_001, TestSize.Level1) +{ + ASSERT_TRUE(g_component != nullptr); + auto iter = outputBuffers.begin(); + if (iter != outputBuffers.end()) { + auto omxBuffer = iter->second->omxBuffer; + auto tempId = omxBuffer->bufferId; + omxBuffer->bufferId = BUFFER_ID_ERROR; + int32_t ret = g_component->FreeBuffer(g_component, (uint32_t)PortIndex::PORT_INDEX_OUTPUT, omxBuffer.get()); + ASSERT_NE(ret, HDF_SUCCESS); + omxBuffer->bufferId = tempId; + } +} + +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiFreeBufferTest_002, TestSize.Level1) { ASSERT_TRUE(g_component != nullptr); auto iter = outputBuffers.begin(); @@ -587,7 +1024,21 @@ HWTEST_F(CodecHdiOmxTest, HdfCodecFreeBufferTest_001, TestSize.Level1) } // Release input buffer -HWTEST_F(CodecHdiOmxTest, HdfCodecFreeBufferTest_002, TestSize.Level1) +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiFreeBufferTest_003, TestSize.Level1) +{ + ASSERT_TRUE(g_component != nullptr); + auto iter = inputBuffers.begin(); + if (iter != inputBuffers.end()) { + auto omxBuffer = iter->second->omxBuffer; + auto tempId = omxBuffer->bufferId; + omxBuffer->bufferId = BUFFER_ID_ERROR; + int32_t ret = g_component->FreeBuffer(g_component, (uint32_t)PortIndex::PORT_INDEX_INPUT, omxBuffer.get()); + ASSERT_NE(ret, HDF_SUCCESS); + omxBuffer->bufferId = tempId; + } +} + +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiFreeBufferTest_004, TestSize.Level1) { ASSERT_TRUE(g_component != nullptr); auto iter = inputBuffers.begin(); @@ -600,7 +1051,7 @@ HWTEST_F(CodecHdiOmxTest, HdfCodecFreeBufferTest_002, TestSize.Level1) } // When ComponentDeInit, must change to Loaded State -HWTEST_F(CodecHdiOmxTest, HdfCodecIdleToLoadedTest_001, TestSize.Level1) +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiIdleToLoadedTest_001, TestSize.Level1) { ASSERT_TRUE(g_component != nullptr); int32_t ret = g_component->SendCommand(g_component, OMX_CommandStateSet, OMX_StateLoaded, nullptr, 0); @@ -614,20 +1065,30 @@ HWTEST_F(CodecHdiOmxTest, HdfCodecIdleToLoadedTest_001, TestSize.Level1) } while (state != OMX_StateLoaded); } -HWTEST_F(CodecHdiOmxTest, HdfCodecDeInitTest_001, TestSize.Level1) +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiDeInitTest_001, TestSize.Level1) { ASSERT_TRUE(g_component != nullptr); int32_t ret = g_component->ComponentDeInit(g_component); ASSERT_EQ(ret, HDF_SUCCESS); } -HWTEST_F(CodecHdiOmxTest, HdfCodecDestoryComponentTest_001, TestSize.Level1) +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiDestoryComponentTest_001, TestSize.Level1) { ASSERT_TRUE(g_component != nullptr); ASSERT_TRUE(g_manager != nullptr); int ret = g_manager->DestoryComponent(g_component); ASSERT_EQ(ret, HDF_SUCCESS); - CodecComponentManagerRelease(); + g_component = nullptr; } #endif // COMPONENT_NAME + +HWTEST_F(CodecHdiOmxTest, HdfCodecHdiReleaseTest_001, TestSize.Level1) +{ + ASSERT_TRUE(g_manager != nullptr); + ASSERT_TRUE(g_callback != nullptr); + CodecCallbackTypeStubRelease(g_callback); + CodecComponentManagerRelease(); + g_callback = nullptr; + g_manager = nullptr; +} } // namespace -- Gitee