xref: /test/xts/hats/hdf/codec/hdi_component_additional/codec_component_test.cpp

/*
 * Copyright (c) 2024 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#include "codec_omx_ext.h"
#include "v3_0/codec_callback_service.h"
#include "v1_0/display_buffer_type.h"
#include "v1_0/display_composer_type.h"
#include "v3_0/icodec_callback.h"
#include "v3_0/icodec_component.h"
#include "v3_0/icodec_component_manager.h"
#include "v1_0/include/idisplay_buffer.h"
#include <OMX_Component.h>
#include <OMX_Core.h>
#include <OMX_Video.h>
#include <OMX_VideoExt.h>
#include <benchmark/benchmark.h>
#include <gtest/gtest.h>
#include <hdf_log.h>
#include <securec.h>
#include <servmgr_hdi.h>
#include <vector>

using namespace std;
using namespace testing::ext;
using OHOS::sptr;
using namespace OHOS::HDI::Codec::V3_0;
namespace {
constexpr CodecType TYPE = CodecType::VIDEO_ENCODER;
constexpr AvCodecRole ROLE = MEDIA_ROLETYPE_VIDEO_AVC;
static sptr<ICodecComponent> g_component = nullptr;
static sptr<ICodecCallback> g_callback = nullptr;
static sptr<ICodecComponentManager> g_manager = nullptr;
static CodecVersionType g_version;
static std::string g_compName = "";
uint32_t g_componentId = 0;
enum class PortIndex { PORT_INDEX_INPUT = 0, PORT_INDEX_OUTPUT = 1 };
const static uint32_t INPUT_INDEX = static_cast<uint32_t>(PortIndex::PORT_INDEX_INPUT);
const static uint32_t OUTPUT_INDEX = static_cast<uint32_t>(PortIndex::PORT_INDEX_OUTPUT);
constexpr int32_t WIDTH = 640;
constexpr int32_t HEIGHT = 480;
constexpr int32_t BUFFER_SIZE = WIDTH * HEIGHT * 3;
constexpr int FD_DEFAULT = -1;
constexpr uint32_t BUFFER_ID_ERROR = 65000;

template <typename T>
void InitParam(T &param)
{
    memset_s(&param, sizeof(param), 0x0, sizeof(param));
    param.size = sizeof(param);
    param.version.nVersion = 1;
}

template <typename T>
void ObjectToVector(T &param, std::vector<int8_t> &vec)
{
    int8_t *paramPointer = reinterpret_cast<int8_t *>(&param);
    vec.insert(vec.end(), paramPointer, paramPointer + sizeof(param));
}

class CodecComponentTestAdditional : public testing::Test {
public:
    void InitOmxCodecBuffer(OmxCodecBuffer &buffer, CodecBufferType type)
    {
        buffer.bufferType = type;
        buffer.fenceFd = -1;
        buffer.version = g_version;
        buffer.allocLen = BUFFER_SIZE;
        buffer.fd = FD_DEFAULT;
        buffer.bufferhandle = nullptr;
        buffer.pts = 0;
        buffer.flag = 0;
        buffer.size = sizeof(OmxCodecBuffer);
        buffer.type = READ_ONLY_TYPE;
    }
    static void SetUpTestCase()
    {
        g_manager = ICodecComponentManager::Get();
        int32_t count = 0;
        auto ret = g_manager->GetComponentNum(count);
        ASSERT_EQ(ret, HDF_SUCCESS);
        if (count <= 0) {
            return;
        }

        std::vector<CodecCompCapability> capList;
        auto err = g_manager->GetComponentCapabilityList(capList, count);
        ASSERT_TRUE(err == HDF_SUCCESS);
        for (auto cap : capList) {
            if (cap.type == TYPE && cap.role == ROLE) {
                g_compName = cap.compName;
                break;
            }
        }
    }
    static void TearDownTestCase() { g_manager = nullptr; }
    void SetUp()
    {
        if (g_manager == nullptr) {
            return;
        }
        g_callback = new CodecCallbackService();
        if (g_callback == nullptr) {
            return;
        }
        if (g_compName.empty()) {
            return;
        }

        auto ret = g_manager->CreateComponent(g_component, g_componentId, g_compName.data(),
                                              reinterpret_cast<int64_t>(this), g_callback);
        if (ret != HDF_SUCCESS) {
            return;
        }
        struct CompVerInfo verInfo;
        ret = g_component->GetComponentVersion(verInfo);
        if (ret != HDF_SUCCESS) {
            return;
        }
        g_version = verInfo.compVersion;
    }
    void TearDown()
    {
        std::vector<int8_t> cmdData;
        if (g_component != nullptr) {
            g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_LOADED, cmdData);
        }
        if (g_manager != nullptr && g_component != nullptr) {
            g_manager->DestroyComponent(g_componentId);
        }
        g_callback = nullptr;
        g_component = nullptr;
    }
};

/**
* @tc.number : SUB_Driver_Codec_GetParameter_0200
* @tc.name   : testGetParameter001
* @tc.desc   : when the index = OMX_IndexCodecVideoPortFormat, structure inParamStruct> portIndex = INPUT_INDEX,
                If inParamStruct->codecColorIndex = 0, the command is successfully sent.
*/
HWTEST_F(CodecComponentTestAdditional, testGetParameter001, Function | MediumTest | Level1)
{
    ASSERT_TRUE(g_component != nullptr);
    CodecVideoPortFormatParam param;
    InitParam(param);
    param.portIndex = INPUT_INDEX;
    param.codecColorIndex = 0;
    std::vector<int8_t> inParam;
    ObjectToVector(param, inParam);
    std::vector<int8_t> outParam;
    auto ret = g_component->GetParameter(OMX_IndexParamVideoPortFormat, inParam, outParam);
    ASSERT_EQ(ret, HDF_SUCCESS);
}
/**
* @tc.number : SUB_Driver_Codec_GetParameter_0300
* @tc.name   : testGetParameter002
* @tc.desc   : When the index = OMX_IndexParamVideoQuantization, structure inParamStruct->portIndex = INPUT_INDEX,
                inParamStruct->codecColorIndex = 0, Failed to send the command.
*/
HWTEST_F(CodecComponentTestAdditional, testGetParameter002, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    CodecVideoPortFormatParam param;
    InitParam(param);
    param.portIndex = INPUT_INDEX;
    param.codecColorIndex = 0;
    std::vector<int8_t> inParam;
    ObjectToVector(param, inParam);
    std::vector<int8_t> outParam;
    auto ret = g_component->GetParameter(OMX_IndexParamVideoQuantization, inParam, outParam);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
* @tc.number : SUB_Driver_Codec_GetParameter_0400
* @tc.name   : testGetParameter003
* @tc.desc   : When index=OMX_IndexParamVideoFastUpdate, Structure inParamStruct->portIndex=INPUT_INDEX,
                inParamStruct->codecColorIndex=0, sending command failed.
*/
HWTEST_F(CodecComponentTestAdditional, testGetParameter003, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    CodecVideoPortFormatParam param;
    InitParam(param);
    param.portIndex = INPUT_INDEX;
    param.codecColorIndex = 0;
    std::vector<int8_t> inParam;
    ObjectToVector(param, inParam);
    std::vector<int8_t> outParam;
    auto ret = g_component->GetParameter(OMX_IndexParamVideoFastUpdate, inParam, outParam);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
* @tc.number : SUB_Driver_Codec_GetParameter_0500
* @tc.name   : testGetParameter004
* @tc.desc   : When index = OMX_IndexParamVideoBitrate, structure inParamStruct->portIndex = INPUT_INDEX,
                inParamStruct->codecColorIndex = 0,Failed to send command.
*/
HWTEST_F(CodecComponentTestAdditional, testGetParameter004, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    CodecVideoPortFormatParam param;
    InitParam(param);
    param.portIndex = INPUT_INDEX;
    param.codecColorIndex = 0;
    std::vector<int8_t> inParam;
    ObjectToVector(param, inParam);
    std::vector<int8_t> outParam;
    auto ret = g_component->GetParameter(OMX_IndexParamVideoBitrate, inParam, outParam);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
* @tc.number : SUB_Driver_Codec_GetParameter_0600
* @tc.name   : testGetParameter005
* @tc.desc   : When the index = OMX_IndexCodecVideoPortFormat, structure inParamStruct->portIndex = INPUT_INDEX,
                inParamStruct->codecColorIndex = 0,Send command successful.
*/
HWTEST_F(CodecComponentTestAdditional, testGetParameter005, Function | MediumTest | Level1)
{
    ASSERT_TRUE(g_component != nullptr);
    CodecVideoPortFormatParam param;
    InitParam(param);
    std::vector<int8_t> inParam;
    ObjectToVector(param, inParam);
    std::vector<int8_t> outParam;
    auto ret = g_component->GetParameter(OMX_IndexParamVideoPortFormat, inParam, outParam);
    ASSERT_EQ(ret, HDF_SUCCESS);
}
/**
* @tc.number : SUB_Driver_Codec_GetParameter_0700
* @tc.name   : testGetParameter006
* @tc.desc   : When the index = OMX_IndexCodecVideoPortFormat, structure inParamStruct->portIndex = OUTPUT_INDEX,
                not initialize,  send the command failed
*/
HWTEST_F(CodecComponentTestAdditional, testGetParameter006, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    CodecVideoPortFormatParam param;
    param.portIndex = OUTPUT_INDEX;
    std::vector<int8_t> inParam;
    ObjectToVector(param, inParam);
    std::vector<int8_t> outParam;
    auto ret = g_component->GetParameter(OMX_IndexParamVideoPortFormat, inParam, outParam);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
* @tc.number : SUB_Driver_Codec_GetParameter_0800
* @tc.name   : testGetParameter007
* @tc.desc   : When the index = OMX_IndexParamVideoIntraRefresh,structure inParamStruct not initialize,
                send the command failed
*/
HWTEST_F(CodecComponentTestAdditional, testGetParameter007, Function | MediumTest | Level2)
{
    int32_t ret;
    std::vector<int8_t> inParam;
    std::vector<int8_t> outParam;
    ret = g_component->GetParameter(OMX_IndexParamVideoIntraRefresh, inParam, outParam);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
* @tc.number : SUB_Driver_Codec_GetParameter_0900
* @tc.name   : testGetParameter008
* @tc.desc   : When the index = OMX_IndexCodecVideoPortFormat, structure inParamStruct->portIndex = OUTPUT_INDEX,
                send the command succeeds
*/
HWTEST_F(CodecComponentTestAdditional, testGetParameter008, Function | MediumTest | Level1)
{
    ASSERT_TRUE(g_component != nullptr);
    CodecVideoPortFormatParam param;
    InitParam(param);
    param.portIndex = OUTPUT_INDEX;
    std::vector<int8_t> inParam;
    ObjectToVector(param, inParam);
    std::vector<int8_t> outParam;
    auto ret = g_component->GetParameter(OMX_IndexParamVideoPortFormat, inParam, outParam);
    ASSERT_EQ(ret, HDF_SUCCESS);
}
/**
* @tc.number : SUB_Driver_Codec_SetParameter_0200
* @tc.name   : testSetParameter001
* @tc.desc   : When the index = OMX_IndexParamVideoPortFormat paramStruct. PortIndex = INPUT_INDEX,
                send the command succeeds
*/
HWTEST_F(CodecComponentTestAdditional, testSetParameter001, Function | MediumTest | Level1)
{
    ASSERT_TRUE(g_component != nullptr);
    int32_t ret;
    CodecVideoPortFormatParam param;
    InitParam(param);
    param.portIndex = INPUT_INDEX;
    std::vector<int8_t> paramVec;
    ObjectToVector(param, paramVec);
    ret = g_component->SetParameter(OMX_IndexParamVideoPortFormat, paramVec);
    ASSERT_EQ(ret, HDF_SUCCESS);
}
/**
* @tc.number : SUB_Driver_Codec_SetParameter_0300
* @tc.name   : testSetParameter002
* @tc.desc   : When the index = OMX_IndexParamVideoPortFormat paramStruct. Size = 0,
                send the command failure.
*/
HWTEST_F(CodecComponentTestAdditional, testSetParameter002, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    int32_t ret;
    CodecVideoPortFormatParam param;
    InitParam(param);
    param.portIndex = INPUT_INDEX;
    param.size = 0;
    std::vector<int8_t> paramVec;
    ObjectToVector(param, paramVec);
    ret = g_component->SetParameter(OMX_IndexParamVideoPortFormat, paramVec);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_SetParameter_0400
 * @tc.name   : testSetParameter003
 * @tc.desc   : When paramStruct. CodecColorIndex = 0, send the command succeeds.
 */
HWTEST_F(CodecComponentTestAdditional, testSetParameter003, Function | MediumTest | Level1)
{
    ASSERT_TRUE(g_component != nullptr);
    int32_t ret;
    CodecVideoPortFormatParam param;
    InitParam(param);
    param.portIndex = INPUT_INDEX;
    param.codecColorIndex = 0;
    std::vector<int8_t> paramVec;
    ObjectToVector(param, paramVec);
    ret = g_component->SetParameter(OMX_IndexParamVideoPortFormat, paramVec);
    ASSERT_EQ(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_SetParameter_0500
 * @tc.name   : testSetParameter004
 * @tc.desc   : When paramStruct->CodecColorFormat = 20, send the command succeeds.
 */
HWTEST_F(CodecComponentTestAdditional, testSetParameter004, Function | MediumTest | Level1)
{
    ASSERT_TRUE(g_component != nullptr);
    int32_t ret;
    CodecVideoPortFormatParam param;
    InitParam(param);
    param.portIndex = INPUT_INDEX;
    param.codecColorFormat = 20;
    std::vector<int8_t> paramVec;
    ObjectToVector(param, paramVec);
    ret = g_component->SetParameter(OMX_IndexParamVideoPortFormat, paramVec);
    ASSERT_EQ(ret, HDF_SUCCESS);
}
/**
* @tc.number : SUB_Driver_Codec_SetParameter_0600
* @tc.name   : testSetParameter005
* @tc.desc   : When the index = OMX_IndexParamVideoPortFormat, paramStruct->CodecColorFormat = 0,
                send the command succeeds.
*/
HWTEST_F(CodecComponentTestAdditional, testSetParameter005, Function | MediumTest | Level1)
{
    ASSERT_TRUE(g_component != nullptr);
    int32_t ret;
    CodecVideoPortFormatParam param;
    InitParam(param);
    param.portIndex = INPUT_INDEX;
    param.codecColorFormat = 0;
    std::vector<int8_t> paramVec;
    ObjectToVector(param, paramVec);
    ret = g_component->SetParameter(OMX_IndexParamVideoPortFormat, paramVec);
    ASSERT_EQ(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_SetParameter_0700
 * @tc.name   : testSetParameter006
 * @tc.desc   : When the index = OMX_IndexParamVideoQuantization, send the command failed.
 */
HWTEST_F(CodecComponentTestAdditional, testSetParameter006, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    int32_t ret;
    CodecVideoPortFormatParam param;
    InitParam(param);
    param.portIndex = INPUT_INDEX;
    std::vector<int8_t> paramVec;
    ObjectToVector(param, paramVec);
    ret = g_component->SetParameter(OMX_IndexParamVideoQuantization, paramVec);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
* @tc.number : SUB_Driver_Codec_GetConfig_0200
* @tc.name   : testGetConfig001
* @tc.desc   : If index = OMX_IndexConfigVideoBitrate and structure inParamStruct->portIndex = OUTPUT_INDEX,
                the command is failed sent
*/
HWTEST_F(CodecComponentTestAdditional, testGetConfig001, Function | MediumTest | Level1)
{
    ASSERT_TRUE(g_component != nullptr);
    CodecVideoPortFormatParam param;
    InitParam(param);
    param.portIndex = OUTPUT_INDEX;

    std::vector<int8_t> inParam;
    ObjectToVector(param, inParam);
    std::vector<int8_t> outParam;
    auto ret = g_component->GetConfig(OMX_IndexConfigVideoBitrate, inParam, outParam);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
* @tc.number : SUB_Driver_Codec_GetConfig_0300
* @tc.name   : testGetConfig002
* @tc.desc   : When the index = OMX_IndexParamVideoPortFormat, structure inParamStruct->portIndex = OUTPUT_INDEX,
                send the command failed,not initialized.
*/
HWTEST_F(CodecComponentTestAdditional, testGetConfig002, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    CodecVideoPortFormatParam param;
    param.portIndex = OUTPUT_INDEX;

    std::vector<int8_t> inParam;
    ObjectToVector(param, inParam);
    std::vector<int8_t> outParam;
    auto ret = g_component->GetConfig(OMX_IndexParamVideoPortFormat, inParam, outParam);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
* @tc.number : SUB_Driver_Codec_GetConfig_0400
* @tc.name   : testGetConfig003
* @tc.desc   : When index=OMX_IndexParamVideoBitrate, structure inParamStruct->portIndex=OUTPUT_INDEX,
                sending command failed
*/
HWTEST_F(CodecComponentTestAdditional, testGetConfig003, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    CodecVideoPortFormatParam param;
    InitParam(param);
    param.portIndex = OUTPUT_INDEX;

    std::vector<int8_t> inParam;
    ObjectToVector(param, inParam);
    std::vector<int8_t> outParam;
    auto ret = g_component->GetConfig(OMX_IndexParamVideoBitrate, inParam, outParam);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
* @tc.number : SUB_Driver_Codec_GetConfig_0500
* @tc.name   : testGetConfig004
* @tc.desc   : When index=OMX_IndexParamVideoFastUpdate, Structure inParamStruct->portIndex=OUTPUT_INDEX,
                sending command failed
*/
HWTEST_F(CodecComponentTestAdditional, testGetConfig004, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    CodecVideoPortFormatParam param;
    InitParam(param);
    param.portIndex = OUTPUT_INDEX;

    std::vector<int8_t> inParam;
    ObjectToVector(param, inParam);
    std::vector<int8_t> outParam;
    auto ret = g_component->GetConfig(OMX_IndexParamVideoFastUpdate, inParam, outParam);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
* @tc.number : SUB_Driver_Codec_GetConfig_0600
* @tc.name   : testGetConfig005
* @tc.desc   : When index=OMX_IndexParamVideoQuantization, structure inParamStruct->portIndex=OUTPUT_INDEX,
                sending command failed
*/
HWTEST_F(CodecComponentTestAdditional, testGetConfig005, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    CodecVideoPortFormatParam param;
    InitParam(param);
    param.portIndex = OUTPUT_INDEX;

    std::vector<int8_t> inParam;
    ObjectToVector(param, inParam);
    std::vector<int8_t> outParam;
    auto ret = g_component->GetConfig(OMX_IndexParamVideoQuantization, inParam, outParam);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
* @tc.number : SUB_Driver_Codec_SetConfig_0300
* @tc.name   : testSetConfig002
* @tc.desc   : When index=OMX_IndexConfigVideoBitrate, structure inParamStruct->portIndex=INPUT_INDEX,
                sending command failed
*/
HWTEST_F(CodecComponentTestAdditional, testSetConfig002, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    CodecVideoPortFormatParam param;
    InitParam(param);
    param.portIndex = INPUT_INDEX;

    std::vector<int8_t> inParam;
    ObjectToVector(param, inParam);
    auto ret = g_component->SetConfig(OMX_IndexConfigVideoBitrate, inParam);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
* @tc.number : SUB_Driver_Codec_SetConfig_0400
* @tc.name   : testSetConfig003
* @tc.desc   : When index=OMX_IndexParamVideoQuantization, structure inParamStruct->portIndex=OUTPUT_INDEX,
                sending command failed
*/
HWTEST_F(CodecComponentTestAdditional, testSetConfig003, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    CodecVideoPortFormatParam param;
    InitParam(param);
    param.portIndex = OUTPUT_INDEX;

    std::vector<int8_t> inParam;
    ObjectToVector(param, inParam);
    auto ret = g_component->SetConfig(OMX_IndexParamVideoQuantization, inParam);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
* @tc.number : SUB_Driver_Codec_SetConfig_0500
* @tc.name   : testSetConfig004
* @tc.desc   : When index=OMX_IndexVideoStartUnused, Structure inParamStruct->portIndex=OUTPUT_INDEX,
                sending command failed
*/
HWTEST_F(CodecComponentTestAdditional, testSetConfig004, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    CodecVideoPortFormatParam param;
    InitParam(param);
    param.portIndex = OUTPUT_INDEX;

    std::vector<int8_t> inParam;
    ObjectToVector(param, inParam);
    auto ret = g_component->SetConfig(OMX_IndexVideoStartUnused, inParam);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
* @tc.number : SUB_Driver_Codec_SetConfig_0600
* @tc.name   : testSetConfig005
* @tc.desc   : When index=OMX_IndexCodecVideoPortFormat, Structure inParamStruct->portIndex=OUTPUT_INDEX,
               not initialized,sending command failed.
*/
HWTEST_F(CodecComponentTestAdditional, testSetConfig005, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    CodecVideoPortFormatParam param;
    param.portIndex = OUTPUT_INDEX;

    std::vector<int8_t> inParam;
    ObjectToVector(param, inParam);
    auto ret = g_component->SetConfig(OMX_IndexParamVideoPortFormat, inParam);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
* @tc.number : SUB_Driver_Codec_SetConfig_0700
* @tc.name   : testSetConfig006
* @tc.desc   : When index=OMX_IndexParamVideoFastUpdate, Structure inParamStruct->portIndex=OUTPUT_INDEX,
                sending command failed
*/
HWTEST_F(CodecComponentTestAdditional, testSetConfig006, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    CodecVideoPortFormatParam param;
    InitParam(param);
    param.portIndex = OUTPUT_INDEX;

    std::vector<int8_t> inParam;
    ObjectToVector(param, inParam);
    auto ret = g_component->SetConfig(OMX_IndexParamVideoFastUpdate, inParam);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
* @tc.number : SUB_Driver_Codec_SetConfig_0800
* @tc.name   : testSetConfig007
* @tc.desc   : When index=OMX_IndexConfigVideoBitrate, structure inParamStruct->codecColorIndex=0,
                command sent failed.
*/
HWTEST_F(CodecComponentTestAdditional, testSetConfig007, Function | MediumTest | Level1)
{
    ASSERT_TRUE(g_component != nullptr);
    CodecVideoPortFormatParam param;
    InitParam(param);
    param.portIndex = OUTPUT_INDEX;
    param.codecColorIndex = 0;

    std::vector<int8_t> inParam;
    ObjectToVector(param, inParam);
    auto ret = g_component->SetConfig(OMX_IndexConfigVideoBitrate, inParam);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_SetConfig_0900
 * @tc.name   : testSetConfig008
 * @tc.desc   : When index=OMX_IndexConfigVideoBitrate, structure inParamStruct->size=0, command sent failed.
 */
HWTEST_F(CodecComponentTestAdditional, testSetConfig008, Function | MediumTest | Level1)
{
    ASSERT_TRUE(g_component != nullptr);
    CodecVideoPortFormatParam param;
    InitParam(param);
    param.portIndex = OUTPUT_INDEX;
    param.size = 0;

    std::vector<int8_t> inParam;
    ObjectToVector(param, inParam);
    auto ret = g_component->SetConfig(OMX_IndexConfigVideoBitrate, inParam);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_SetConfig_1000
 * @tc.name   : testSetConfig009
 * @tc.desc   : When index=OMX_IndexConfigVideoBitrate, structure inParamStruct->codecColorFormat=0,
 *              command sent failed.
 */
HWTEST_F(CodecComponentTestAdditional, testSetConfig009, Function | MediumTest | Level1)
{
    ASSERT_TRUE(g_component != nullptr);
    CodecVideoPortFormatParam param;
    InitParam(param);
    param.portIndex = OUTPUT_INDEX;
    param.codecColorFormat = 0;

    std::vector<int8_t> inParam;
    ObjectToVector(param, inParam);
    auto ret = g_component->SetConfig(OMX_IndexConfigVideoBitrate, inParam);
    ASSERT_NE(ret, HDF_SUCCESS);
}

#ifdef SUPPORT_OMX
/**
 * @tc.number : SUB_Driver_Codec_GetExtensionIndex_0200
 * @tc.name   : testGetExtensionIndex001
 * @tc.desc   : When the paramName is "OMX.Topaz.index.param.extended_video" and the indexType = 0,
 *              sending the command is successful.
 */
HWTEST_F(CodecComponentTestAdditional, testGetExtensionIndex001, Function | MediumTest | Level1)
{
    ASSERT_TRUE(g_component != nullptr);
    uint32_t indexType = 0;
    auto ret = g_component->GetExtensionIndex("OMX.Topaz.index.param.extended_video", indexType);
    ASSERT_EQ(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_GetExtensionIndex_0300
 * @tc.name   : testGetExtensionIndex002
 * @tc.desc   : Sending command failed when paramName is "" and indexType = 0.
 */
HWTEST_F(CodecComponentTestAdditional, testGetExtensionIndex002, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    uint32_t indexType = 0;
    auto ret = g_component->GetExtensionIndex("", indexType);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_GetExtensionIndex_0400
 * @tc.name   : testGetExtensionIndex003
 * @tc.desc   : When the paramName is "ＯＭＸ．Ｔｏｐａｚ．ｉｎｄｅｘ．ｐａｒａｍ．ｅｘｔｅｎｄｅｄ＿ｖｉｄｅｏ" and the
 * indexType = 0 Verify full width letters and symbols
 */
HWTEST_F(CodecComponentTestAdditional, testGetExtensionIndex003, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    uint32_t indexType = 0;
    auto ret = g_component->GetExtensionIndex(
        "ＯＭＸ．Ｔｏｐａｚ．ｉｎｄｅｘ．ｐａｒａｍ．ｅｘｔｅｎｄｅｄ＿ｖｉｄｅｏ", indexType);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_GetExtensionIndex_0500
 * @tc.name   : testGetExtensionIndex004
 * @tc.desc   : When the paramName is "!@#$%^&**" and the indexType = 0 Verify half width symbols
 */
HWTEST_F(CodecComponentTestAdditional, testGetExtensionIndex004, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    uint32_t indexType = 0;
    auto ret = g_component->GetExtensionIndex("!@#$%^&**", indexType);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_GetExtensionIndex_0600
 * @tc.name   : testGetExtensionIndex005
 * @tc.desc   : When the paramName is "！＠＃＄％＾＆＊＊" and the indexType = 0 Verify full width symbols
 */
HWTEST_F(CodecComponentTestAdditional, testGetExtensionIndex005, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    uint32_t indexType = 0;
    auto ret = g_component->GetExtensionIndex("！＠＃＄％＾＆＊＊", indexType);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_GetExtensionIndex_0700
 * @tc.name   : testGetExtensionIndex006
 * @tc.desc   : When the paramName is "12345" and the indexType = 0 Verify Half width Numbers
 */
HWTEST_F(CodecComponentTestAdditional, testGetExtensionIndex006, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    uint32_t indexType = 0;
    auto ret = g_component->GetExtensionIndex("12345", indexType);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_GetExtensionIndex_0800
 * @tc.name   : testGetExtensionIndex007
 * @tc.desc   : When the paramName is "12345MX.Topaz" and the indexType = 0 Verify half width numbers,
 * half width letters, and half width symbols
 */
HWTEST_F(CodecComponentTestAdditional, testGetExtensionIndex007, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    uint32_t indexType = 0;
    auto ret = g_component->GetExtensionIndex("12345MX.Topaz", indexType);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_GetExtensionIndex_0900
 * @tc.name   : testGetExtensionIndex008
 * @tc.desc   : When the paramName is "!@#$%^&**OMX.Topaz" and the indexType = 0 Verify half width symbols and
 * half width letters
 */
HWTEST_F(CodecComponentTestAdditional, testGetExtensionIndex008, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    uint32_t indexType = 0;
    auto ret = g_component->GetExtensionIndex("!@#$%^&**OMX.Topaz", indexType);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_GetExtensionIndex_1000
 * @tc.name   : testGetExtensionIndex009
 * @tc.desc   : When the paramName is "１２３４５" and the indexType = 0 Verify full angle digits
 */
HWTEST_F(CodecComponentTestAdditional, testGetExtensionIndex009, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    uint32_t indexType = 0;
    auto ret = g_component->GetExtensionIndex("１２３４５", indexType);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_GetExtensionIndex_1100
 * @tc.name   : testGetExtensionIndex010
 * @tc.desc   : When the paramName is "１２３４５ＯＭＸ．Ｔｏｐａｚ" and the indexType = 0 Verify full width digits,
 * full width letters, and full width symbols
 */
HWTEST_F(CodecComponentTestAdditional, testGetExtensionIndex010, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    uint32_t indexType = 0;
    auto ret = g_component->GetExtensionIndex("１２３４５ＯＭＸ．Ｔｏｐａｚ", indexType);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_GetExtensionIndex_1200
 * @tc.name   : testGetExtensionIndex011
 * @tc.desc   : When the paramName is "１２３４５!@#$%" and the indexType = 0 Verify full width digits and
 * half width symbols
 */
HWTEST_F(CodecComponentTestAdditional, testGetExtensionIndex011, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    uint32_t indexType = 0;
    auto ret = g_component->GetExtensionIndex("１２３４５Ｏ!@#$%", indexType);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_GetExtensionIndex_1300
 * @tc.name   : testGetExtensionIndex012
 * @tc.desc   : When the paramName is "１２３４５！＠＃＄" and the indexType = 0 Verify full width digits, full width
 * symbols
 */
HWTEST_F(CodecComponentTestAdditional, testGetExtensionIndex012, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    uint32_t indexType = 0;
    auto ret = g_component->GetExtensionIndex("１２３４５！＠＃＄", indexType);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_GetExtensionIndex_1400
 * @tc.name   : testGetExtensionIndex013
 * @tc.desc   : When the paramName is "１２３４５OMX.Topaz" and the indexType = 0 Verify full width numbers,
 * half width letters, and half width symbols
 */
HWTEST_F(CodecComponentTestAdditional, testGetExtensionIndex013, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    uint32_t indexType = 0;
    auto ret = g_component->GetExtensionIndex("１２３４５OMX.Topaz", indexType);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_GetExtensionIndex_1500
 * @tc.name   : testGetExtensionIndex014
 * @tc.desc   : When the paramName is "！＠＃＄％OMX.Topaz" and the indexType = 0 Verify full width symbols,
 * half width letters, and half width symbols
 */
HWTEST_F(CodecComponentTestAdditional, testGetExtensionIndex014, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    uint32_t indexType = 0;
    auto ret = g_component->GetExtensionIndex("！＠＃＄％OMX.Topaz", indexType);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_GetExtensionIndex_1600
 * @tc.name   : testGetExtensionIndex015
 * @tc.desc   : When the paramName is "！＠＃＄％ＯＭＸ．Ｔｏｐａｚ" and the indexType = 0 Verify full width symbols and
 * letters
 */
HWTEST_F(CodecComponentTestAdditional, testGetExtensionIndex015, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    uint32_t indexType = 0;
    auto ret = g_component->GetExtensionIndex("！＠＃＄％ＯＭＸ．Ｔｏｐａｚ", indexType);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_GetExtensionIndex_1700
 * @tc.name   : testGetExtensionIndex016
 * @tc.desc   : When the paramName is "12345ＯＭＸ．Ｔｏｐａｚ" and the indexType = 0 Verify half width numbers,
 * full width letters, and full width symbols
 */
HWTEST_F(CodecComponentTestAdditional, testGetExtensionIndex016, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    uint32_t indexType = 0;
    auto ret = g_component->GetExtensionIndex("12345ＯＭＸ．Ｔｏｐａｚ", indexType);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_GetExtensionIndex_1800
 * @tc.name   : testGetExtensionIndex017
 * @tc.desc   : When the paramName is "12345!@#$%" and the indexType = 0 Verify half width numbers
 * and half width symbols
 */
HWTEST_F(CodecComponentTestAdditional, testGetExtensionIndex017, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    uint32_t indexType = 0;
    auto ret = g_component->GetExtensionIndex("12345!@#$%", indexType);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_GetExtensionIndex_1900
 * @tc.name   : testGetExtensionIndex018
 * @tc.desc   : When the paramName is "12345！＠＃＄％" and the indexType = 0 Verify half width numbers
 * and full width symbols
 */
HWTEST_F(CodecComponentTestAdditional, testGetExtensionIndex018, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    uint32_t indexType = 0;
    auto ret = g_component->GetExtensionIndex("12345！＠＃＄％", indexType);
    ASSERT_NE(ret, HDF_SUCCESS);
}
#endif
/**
 * @tc.number : SUB_Driver_Codec_GetState_0200
 * @tc.name   : testGetState001
 * @tc.desc   : When the initial value of CodecStateType is CODEC_STATE_INVALID, does the function modify it.
 */
HWTEST_F(CodecComponentTestAdditional, testGetState001, Function | MediumTest | Level1)
{
    ASSERT_TRUE(g_component != nullptr);
    CodecStateType state = CODEC_STATE_INVALID;
    int32_t ret = g_component->GetState(state);
    ASSERT_EQ(state, CODEC_STATE_LOADED);
    ASSERT_EQ(ret, HDF_SUCCESS);
}
#ifdef SUPPORT_OMX
/**
 * @tc.number : SUB_Driver_Codec_ComponentTunnelRequest_0200
 * @tc.name   : testComponentTunnelRequest001
 * @tc.desc   : When setting the component status to OMX_StateInvalid, input port=OUTPUT_INDEX, tunneledComp=1,
 *              tunneledPort=1,inTunnelSetup=CODEC_BUFFER_SUPPLY_INPUT, sending command failed.
 */
HWTEST_F(CodecComponentTestAdditional, testComponentTunnelRequest001, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    auto ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, OMX_StateInvalid, cmdData);
    ASSERT_EQ(ret, HDF_SUCCESS);
    const int32_t tunneledComp = 1;
    const uint32_t tunneledPort = 1;
    OHOS::HDI::Codec::V3_0::CodecTunnelSetupType tunnelSetup;
    tunnelSetup.supplier = OHOS::HDI::Codec::V3_0::CODEC_BUFFER_SUPPLY_INPUT;

    ret = g_component->ComponentTunnelRequest(OUTPUT_INDEX, tunneledComp, tunneledPort, tunnelSetup, tunnelSetup);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_ComponentTunnelRequest_0300
 * @tc.name   : testComponentTunnelRequest002
 * @tc.desc   : When setting the component status to OMX_StateIdle, input port=INPUT_INDEX, tunneledComp=1002,
 *              tunneledPort=101,inTunnelSetup=CODEC_BUFFER_SUPPLY_INPUT,Sending command failed.
 */
HWTEST_F(CodecComponentTestAdditional, testComponentTunnelRequest002, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    auto ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, OMX_StateIdle, cmdData);
    ASSERT_EQ(ret, HDF_SUCCESS);
    const int32_t tunneledComp = 1002;
    const uint32_t tunneledPort = 101;
    OHOS::HDI::Codec::V3_0::CodecTunnelSetupType tunnelSetup;
    tunnelSetup.supplier = OHOS::HDI::Codec::V3_0::CODEC_BUFFER_SUPPLY_INPUT;

    ret = g_component->ComponentTunnelRequest(INPUT_INDEX, tunneledComp, tunneledPort, tunnelSetup, tunnelSetup);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_ComponentTunnelRequest_0400
 * @tc.name   : testComponentTunnelRequest003
 * @tc.desc   : When setting the component status to OMX_ tatePause, input port=INPUT_INDEX, tunneledComp=1002,
 *              tunneledPort=101,inTunnelSetup=CODEC_BUFFER_SUPPLY_OUTPUT, sending command failed.
 */
HWTEST_F(CodecComponentTestAdditional, testComponentTunnelRequest003, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    auto ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, OMX_StatePause, cmdData);
    ASSERT_EQ(ret, HDF_SUCCESS);
    const int32_t tunneledComp = 1002;
    const uint32_t tunneledPort = 101;
    OHOS::HDI::Codec::V3_0::CodecTunnelSetupType tunnelSetup;
    tunnelSetup.supplier = OHOS::HDI::Codec::V3_0::CODEC_BUFFER_SUPPLY_OUTPUT;

    ret = g_component->ComponentTunnelRequest(INPUT_INDEX, tunneledComp, tunneledPort, tunnelSetup, tunnelSetup);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_ComponentTunnelRequest_0500
 * @tc.name   : testComponentTunnelRequest004
 * @tc.desc   : When setting the component status to OMX_StateWaitForResources, input port=OUTPUT_INDEX,
 *              tunneledComp=1002,tunneledPort=101, inTunnelSetup=CODEC_BUFFER_SUPPLY_OUTPUT, sending command failed.
 */
HWTEST_F(CodecComponentTestAdditional, testComponentTunnelRequest004, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    auto ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, OMX_StateWaitForResources, cmdData);
    ASSERT_EQ(ret, HDF_SUCCESS);
    const int32_t tunneledComp = 1002;
    const uint32_t tunneledPort = 101;
    OHOS::HDI::Codec::V3_0::CodecTunnelSetupType tunnelSetup;
    tunnelSetup.supplier = OHOS::HDI::Codec::V3_0::CODEC_BUFFER_SUPPLY_OUTPUT;

    ret = g_component->ComponentTunnelRequest(OUTPUT_INDEX, tunneledComp, tunneledPort, tunnelSetup, tunnelSetup);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_ComponentTunnelRequest_0600
 * @tc.name   : testComponentTunnelRequest005
 * @tc.desc   : When setting the component status to OMX_StateLoaded, input port=OUTPUT_INDEX,
 *              tunneledComp=1002,tunneledPort=101, inTunnelSetup=CODEC_BUFFER_SUPPLY_OUTPUT, sending command failed.
 */
HWTEST_F(CodecComponentTestAdditional, testComponentTunnelRequest005, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    auto ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, OMX_StateLoaded, cmdData);
    ASSERT_EQ(ret, HDF_SUCCESS);
    const int32_t tunneledComp = 1002;
    const uint32_t tunneledPort = 101;
    OHOS::HDI::Codec::V3_0::CodecTunnelSetupType tunnelSetup;
    tunnelSetup.supplier = OHOS::HDI::Codec::V3_0::CODEC_BUFFER_SUPPLY_OUTPUT;

    ret = g_component->ComponentTunnelRequest(OUTPUT_INDEX, tunneledComp, tunneledPort, tunnelSetup, tunnelSetup);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_ComponentTunnelRequest_0700
 * @tc.name   : testComponentTunnelRequest006
 * @tc.desc   : When setting the component status to OMX_StateExecuting, input port=OUTPUT_INDEX,
 *              tunneledComp=1002,tunneledPort=101, inTunnelSetup=CODEC_BUFFER_SUPPLY_OUTPUT, sending command failed.
 */
HWTEST_F(CodecComponentTestAdditional, testComponentTunnelRequest006, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    auto ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, OMX_StateExecuting, cmdData);
    ASSERT_EQ(ret, HDF_SUCCESS);
    const int32_t tunneledComp = 1002;
    const uint32_t tunneledPort = 101;
    OHOS::HDI::Codec::V3_0::CodecTunnelSetupType tunnelSetup;
    tunnelSetup.supplier = OHOS::HDI::Codec::V3_0::CODEC_BUFFER_SUPPLY_OUTPUT;

    ret = g_component->ComponentTunnelRequest(OUTPUT_INDEX, tunneledComp, tunneledPort, tunnelSetup, tunnelSetup);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_ComponentTunnelRequest_0800
 * @tc.name   : testComponentTunnelRequest007
 * @tc.desc   : When setting the component status to OMX_StateKhronosExtensions, input port=OUTPUT_INDEX,
 *              tunneledComp=1002,tunneledPort=101, inTunnelSetup=CODEC_BUFFER_SUPPLY_OUTPUT, sending command failed.
 */
HWTEST_F(CodecComponentTestAdditional, testComponentTunnelRequest007, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    auto ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, OMX_StateKhronosExtensions, cmdData);
    ASSERT_EQ(ret, HDF_SUCCESS);
    const int32_t tunneledComp = 1002;
    const uint32_t tunneledPort = 101;
    OHOS::HDI::Codec::V3_0::CodecTunnelSetupType tunnelSetup;
    tunnelSetup.supplier = OHOS::HDI::Codec::V3_0::CODEC_BUFFER_SUPPLY_OUTPUT;

    ret = g_component->ComponentTunnelRequest(OUTPUT_INDEX, tunneledComp, tunneledPort, tunnelSetup, tunnelSetup);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_ComponentTunnelRequest_0900
 * @tc.name   : testComponentTunnelRequest008
 * @tc.desc   : When setting the component status to OMX_StateVendorStartUnused, input port=OUTPUT_INDEX,
 *              tunneledComp=1002,tunneledPort=101, inTunnelSetup=CODEC_BUFFER_SUPPLY_OUTPUT, sending command failed.
 */
HWTEST_F(CodecComponentTestAdditional, testComponentTunnelRequest008, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    auto ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, OMX_StateVendorStartUnused, cmdData);
    ASSERT_EQ(ret, HDF_SUCCESS);
    const int32_t tunneledComp = 1002;
    const uint32_t tunneledPort = 101;
    OHOS::HDI::Codec::V3_0::CodecTunnelSetupType tunnelSetup;
    tunnelSetup.supplier = OHOS::HDI::Codec::V3_0::CODEC_BUFFER_SUPPLY_OUTPUT;

    ret = g_component->ComponentTunnelRequest(OUTPUT_INDEX, tunneledComp, tunneledPort, tunnelSetup, tunnelSetup);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_ComponentTunnelRequest_1000
 * @tc.name   : testComponentTunnelRequest009
 * @tc.desc   : When setting the component status to OMX_StateMax, input port=OUTPUT_INDEX,
 *              tunneledComp=1002,tunneledPort=101, inTunnelSetup=CODEC_BUFFER_SUPPLY_OUTPUT, sending command failed.
 */
HWTEST_F(CodecComponentTestAdditional, testComponentTunnelRequest009, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    auto ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, OMX_StateMax, cmdData);
    ASSERT_EQ(ret, HDF_SUCCESS);
    const int32_t tunneledComp = 1002;
    const uint32_t tunneledPort = 101;
    OHOS::HDI::Codec::V3_0::CodecTunnelSetupType tunnelSetup;
    tunnelSetup.supplier = OHOS::HDI::Codec::V3_0::CODEC_BUFFER_SUPPLY_OUTPUT;

    ret = g_component->ComponentTunnelRequest(OUTPUT_INDEX, tunneledComp, tunneledPort, tunnelSetup, tunnelSetup);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_ComponentTunnelRequest_1100
 * @tc.name   : testComponentTunnelRequest010
 * @tc.desc   : When setting the component status to OMX_StateMax, input port=INPUT_INDEX,
 *              tunneledComp=1002,tunneledPort=101, inTunnelSetup=CODEC_BUFFER_SUPPLY_UNSPECIFIED, sending command
 * failed.
 */
HWTEST_F(CodecComponentTestAdditional, testComponentTunnelRequest010, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    auto ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, OMX_StateMax, cmdData);
    ASSERT_EQ(ret, HDF_SUCCESS);
    const int32_t tunneledComp = 1002;
    const uint32_t tunneledPort = 101;
    OHOS::HDI::Codec::V3_0::CodecTunnelSetupType tunnelSetup;
    tunnelSetup.supplier = OHOS::HDI::Codec::V3_0::CODEC_BUFFER_SUPPLY_UNSPECIFIED;

    ret = g_component->ComponentTunnelRequest(INPUT_INDEX, tunneledComp, tunneledPort, tunnelSetup, tunnelSetup);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_ComponentTunnelRequest_1200
 * @tc.name   : testComponentTunnelRequest011
 * @tc.desc   : When setting the component status to OMX_StateMax, input port=INPUT_INDEX,
 *              tunneledComp=1002,tunneledPort=101, inTunnelSetup=CODEC_BUFFER_SUPPLY_KHRONOS_EXTENSIONS, sending
 * command failed.
 */
HWTEST_F(CodecComponentTestAdditional, testComponentTunnelRequest011, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    auto ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, OMX_StateMax, cmdData);
    ASSERT_EQ(ret, HDF_SUCCESS);
    const int32_t tunneledComp = 1002;
    const uint32_t tunneledPort = 101;
    OHOS::HDI::Codec::V3_0::CodecTunnelSetupType tunnelSetup;
    tunnelSetup.supplier = OHOS::HDI::Codec::V3_0::CODEC_BUFFER_SUPPLY_KHRONOS_EXTENSIONS;

    ret = g_component->ComponentTunnelRequest(INPUT_INDEX, tunneledComp, tunneledPort, tunnelSetup, tunnelSetup);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_ComponentTunnelRequest_1300
 * @tc.name   : testComponentTunnelRequest012
 * @tc.desc   : When setting the component status to OMX_StateMax, input port=INPUT_INDEX,
 *              tunneledComp=1002,tunneledPort=101, inTunnelSetup=CODEC_BUFFER_SUPPLY_VENDOR_START_UNUSED, sending
 * command failed.
 */
HWTEST_F(CodecComponentTestAdditional, testComponentTunnelRequest012, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    auto ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, OMX_StateMax, cmdData);
    ASSERT_EQ(ret, HDF_SUCCESS);
    const int32_t tunneledComp = 1002;
    const uint32_t tunneledPort = 101;
    OHOS::HDI::Codec::V3_0::CodecTunnelSetupType tunnelSetup;
    tunnelSetup.supplier = OHOS::HDI::Codec::V3_0::CODEC_BUFFER_SUPPLY_VENDOR_START_UNUSED;

    ret = g_component->ComponentTunnelRequest(INPUT_INDEX, tunneledComp, tunneledPort, tunnelSetup, tunnelSetup);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_ComponentTunnelRequest_1400
 * @tc.name   : testComponentTunnelRequest013
 * @tc.desc   : When setting the component status to OMX_StateMax, input port=INPUT_INDEX,
 *              tunneledComp=1002,tunneledPort=101, inTunnelSetup=CODEC_BUFFER_SUPPLY_MAX, sending command failed.
 */
HWTEST_F(CodecComponentTestAdditional, testComponentTunnelRequest013, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    auto ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, OMX_StateMax, cmdData);
    ASSERT_EQ(ret, HDF_SUCCESS);
    const int32_t tunneledComp = 1002;
    const uint32_t tunneledPort = 101;
    OHOS::HDI::Codec::V3_0::CodecTunnelSetupType tunnelSetup;
    tunnelSetup.supplier = OHOS::HDI::Codec::V3_0::CODEC_BUFFER_SUPPLY_MAX;

    ret = g_component->ComponentTunnelRequest(INPUT_INDEX, tunneledComp, tunneledPort, tunnelSetup, tunnelSetup);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_ComponentTunnelRequest_1500
 * @tc.name   : testComponentTunnelRequest014
 * @tc.desc   : When setting the component status to OMX_StateMax, input port=OUTPUT_INDEX,
 *              tunneledComp=1002,tunneledPort=101, inTunnelSetup=CODEC_BUFFER_SUPPLY_UNSPECIFIED, sending command
 * failed.
 */
HWTEST_F(CodecComponentTestAdditional, testComponentTunnelRequest014, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    auto ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, OMX_StateMax, cmdData);
    ASSERT_EQ(ret, HDF_SUCCESS);
    const int32_t tunneledComp = 1002;
    const uint32_t tunneledPort = 101;
    OHOS::HDI::Codec::V3_0::CodecTunnelSetupType tunnelSetup;
    tunnelSetup.supplier = OHOS::HDI::Codec::V3_0::CODEC_BUFFER_SUPPLY_UNSPECIFIED;

    ret = g_component->ComponentTunnelRequest(OUTPUT_INDEX, tunneledComp, tunneledPort, tunnelSetup, tunnelSetup);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_ComponentTunnelRequest_1600
 * @tc.name   : testComponentTunnelRequest015
 * @tc.desc   : When setting the component status to OMX_StateMax, input port=OUTPUT_INDEX,
 *              tunneledComp=1002,tunneledPort=101, inTunnelSetup=CODEC_BUFFER_SUPPLY_KHRONOS_EXTENSIONS, sending
 * command failed.
 */
HWTEST_F(CodecComponentTestAdditional, testComponentTunnelRequest015, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    auto ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, OMX_StateMax, cmdData);
    ASSERT_EQ(ret, HDF_SUCCESS);
    const int32_t tunneledComp = 1002;
    const uint32_t tunneledPort = 101;
    OHOS::HDI::Codec::V3_0::CodecTunnelSetupType tunnelSetup;
    tunnelSetup.supplier = OHOS::HDI::Codec::V3_0::CODEC_BUFFER_SUPPLY_KHRONOS_EXTENSIONS;

    ret = g_component->ComponentTunnelRequest(OUTPUT_INDEX, tunneledComp, tunneledPort, tunnelSetup, tunnelSetup);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_ComponentTunnelRequest_1700
 * @tc.name   : testComponentTunnelRequest016
 * @tc.desc   : When setting the component status to OMX_StateMax, input port=OUTPUT_INDEX,
 *              tunneledComp=1002,tunneledPort=101, inTunnelSetup=CODEC_BUFFER_SUPPLY_VENDOR_START_UNUSED, sending
 * command failed.
 */
HWTEST_F(CodecComponentTestAdditional, testComponentTunnelRequest016, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    auto ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, OMX_StateMax, cmdData);
    ASSERT_EQ(ret, HDF_SUCCESS);
    const int32_t tunneledComp = 1002;
    const uint32_t tunneledPort = 101;
    OHOS::HDI::Codec::V3_0::CodecTunnelSetupType tunnelSetup;
    tunnelSetup.supplier = OHOS::HDI::Codec::V3_0::CODEC_BUFFER_SUPPLY_VENDOR_START_UNUSED;

    ret = g_component->ComponentTunnelRequest(OUTPUT_INDEX, tunneledComp, tunneledPort, tunnelSetup, tunnelSetup);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_ComponentTunnelRequest_1800
 * @tc.name   : testComponentTunnelRequest017
 * @tc.desc   : When setting the component status to OMX_StateMax, input port=OUTPUT_INDEX,
 *              tunneledComp=1002,tunneledPort=101, inTunnelSetup=CODEC_BUFFER_SUPPLY_MAX, sending command failed.
 */
HWTEST_F(CodecComponentTestAdditional, testComponentTunnelRequest017, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    auto ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, OMX_StateMax, cmdData);
    ASSERT_EQ(ret, HDF_SUCCESS);
    const int32_t tunneledComp = 1002;
    const uint32_t tunneledPort = 101;
    OHOS::HDI::Codec::V3_0::CodecTunnelSetupType tunnelSetup;
    tunnelSetup.supplier = OHOS::HDI::Codec::V3_0::CODEC_BUFFER_SUPPLY_MAX;

    ret = g_component->ComponentTunnelRequest(OUTPUT_INDEX, tunneledComp, tunneledPort, tunnelSetup, tunnelSetup);
    ASSERT_NE(ret, HDF_SUCCESS);
}
#endif

/**
 * @tc.number : SUB_Driver_Codec_UseBuffer_0200
 * @tc.name   : testUseBuffer001
 * @tc.desc   : When setting the component status to CODEC_State_IDLE, portIndex=INPUT_INDEX,command sent successfully
 */
HWTEST_F(CodecComponentTestAdditional, testUseBuffer001, Function | MediumTest | Level1)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    auto ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_IDLE, cmdData);
    ASSERT_EQ(ret, HDF_SUCCESS);

    std::shared_ptr<OmxCodecBuffer> omxBuffer = std::make_shared<OmxCodecBuffer>();
    InitOmxCodecBuffer(*omxBuffer.get(), CODEC_BUFFER_TYPE_DYNAMIC_HANDLE);

    OmxCodecBuffer outBuffer;
    ret = g_component->UseBuffer(INPUT_INDEX, *omxBuffer.get(), outBuffer);
    ASSERT_EQ(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_UseBuffer_0300
 * @tc.name   : testUseBuffer002
 * @tc.desc   : When setting the component status to CODEC_State_MAX, portIndex=INPUT_INDEX, sending command failed.
 */
HWTEST_F(CodecComponentTestAdditional, testUseBuffer002, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    auto ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_MAX, cmdData);
#ifdef DISPLAY_COMMUNITY
    ASSERT_EQ(ret, HDF_SUCCESS);
#else
    ASSERT_NE(ret, HDF_SUCCESS);
#endif

    std::shared_ptr<OmxCodecBuffer> omxBuffer = std::make_shared<OmxCodecBuffer>();
    InitOmxCodecBuffer(*omxBuffer.get(), CODEC_BUFFER_TYPE_HANDLE);

    OmxCodecBuffer outBuffer;
    ret = g_component->UseBuffer(INPUT_INDEX, *omxBuffer.get(), outBuffer);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_UseBuffer_0400
 * @tc.name   : testUseBuffer003
 * @tc.desc   : When setting the component status to CODEC_STATE_INVALID, portIndex=INPUT_INDEX,sending command failed.
 */
HWTEST_F(CodecComponentTestAdditional, testUseBuffer003, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    auto ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_INVALID, cmdData);
    ASSERT_EQ(ret, HDF_SUCCESS);

    std::shared_ptr<OmxCodecBuffer> omxBuffer = std::make_shared<OmxCodecBuffer>();
    InitOmxCodecBuffer(*omxBuffer.get(), CODEC_BUFFER_TYPE_HANDLE);

    OmxCodecBuffer outBuffer;
    ret = g_component->UseBuffer(INPUT_INDEX, *omxBuffer.get(), outBuffer);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_UseBuffer_0500
 * @tc.name   : testUseBuffer004
 * @tc.desc   : setting the component status to CODEC_STATE_LOADED, portIndex=INPUT_INDEX,sending command failed.
 */
HWTEST_F(CodecComponentTestAdditional, testUseBuffer004, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    auto ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_LOADED, cmdData);
    ASSERT_EQ(ret, HDF_SUCCESS);

    std::shared_ptr<OmxCodecBuffer> omxBuffer = std::make_shared<OmxCodecBuffer>();
    InitOmxCodecBuffer(*omxBuffer.get(), CODEC_BUFFER_TYPE_HANDLE);

    OmxCodecBuffer outBuffer;
    ret = g_component->UseBuffer(INPUT_INDEX, *omxBuffer.get(), outBuffer);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_UseBuffer_0600
 * @tc.name   : testUseBuffer005
 * @tc.desc   : setting the component status to CODEC_STATE_EXECUTING, portIndex=INPUT_INDEX,sending command failed.
 */
HWTEST_F(CodecComponentTestAdditional, testUseBuffer005, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    auto ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_EXECUTING, cmdData);
    ASSERT_EQ(ret, HDF_SUCCESS);

    std::shared_ptr<OmxCodecBuffer> omxBuffer = std::make_shared<OmxCodecBuffer>();
    InitOmxCodecBuffer(*omxBuffer.get(), CODEC_BUFFER_TYPE_HANDLE);

    OmxCodecBuffer outBuffer;
    ret = g_component->UseBuffer(INPUT_INDEX, *omxBuffer.get(), outBuffer);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_UseBuffer_0700
 * @tc.name   : testUseBuffer006
 * @tc.desc   : setting the component status to CODEC_STATE_PAUSE, portIndex=INPUT_INDEX,sending command failed.
 */
HWTEST_F(CodecComponentTestAdditional, testUseBuffer006, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    auto ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_PAUSE, cmdData);
    ASSERT_EQ(ret, HDF_SUCCESS);

    std::shared_ptr<OmxCodecBuffer> omxBuffer = std::make_shared<OmxCodecBuffer>();
    InitOmxCodecBuffer(*omxBuffer.get(), CODEC_BUFFER_TYPE_HANDLE);

    OmxCodecBuffer outBuffer;
    ret = g_component->UseBuffer(INPUT_INDEX, *omxBuffer.get(), outBuffer);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_UseBuffer_0800
 * @tc.name   : testUseBuffer007
 * @tc.desc   : setting the component status to CODEC_STATE_VENDOR_START_UNUSED, portIndex=INPUT_INDEX,
 *              sending command failed.
 */
HWTEST_F(CodecComponentTestAdditional, testUseBuffer007, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    auto ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_VENDOR_START_UNUSED, cmdData);
#ifdef DISPLAY_COMMUNITY
    ASSERT_EQ(ret, HDF_SUCCESS);
#else
    ASSERT_NE(ret, HDF_SUCCESS);
#endif

    std::shared_ptr<OmxCodecBuffer> omxBuffer = std::make_shared<OmxCodecBuffer>();
    InitOmxCodecBuffer(*omxBuffer.get(), CODEC_BUFFER_TYPE_HANDLE);

    OmxCodecBuffer outBuffer;
    ret = g_component->UseBuffer(INPUT_INDEX, *omxBuffer.get(), outBuffer);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_UseBuffer_0900
 * @tc.name   : testUseBuffer008
 * @tc.desc   : setting the component status to CODEC_STATE_WAIT_FOR_RESOURCES, portIndex=INPUT_INDEX,
 *              sending command failed.
 */
HWTEST_F(CodecComponentTestAdditional, testUseBuffer008, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    auto ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_WAIT_FOR_RESOURCES, cmdData);
    ASSERT_EQ(ret, HDF_SUCCESS);

    std::shared_ptr<OmxCodecBuffer> omxBuffer = std::make_shared<OmxCodecBuffer>();
    InitOmxCodecBuffer(*omxBuffer.get(), CODEC_BUFFER_TYPE_HANDLE);

    OmxCodecBuffer outBuffer;
    ret = g_component->UseBuffer(INPUT_INDEX, *omxBuffer.get(), outBuffer);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_UseBuffer_1000
 * @tc.name   : testUseBuffer009
 * @tc.desc   : setting the component status to CODEC_STATE_IDLE, portIndex=OUTPUT_INDEX,sending command Success.
 */
HWTEST_F(CodecComponentTestAdditional, testUseBuffer009, Function | MediumTest | Level1)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    auto ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_IDLE, cmdData);
    ASSERT_EQ(ret, HDF_SUCCESS);

    std::shared_ptr<OmxCodecBuffer> omxBuffer = std::make_shared<OmxCodecBuffer>();
    InitOmxCodecBuffer(*omxBuffer.get(), CODEC_BUFFER_TYPE_DYNAMIC_HANDLE);

    OmxCodecBuffer outBuffer;
    ret = g_component->UseBuffer(OUTPUT_INDEX, *omxBuffer.get(), outBuffer);
    ASSERT_EQ(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_AllocateBuffer_0200
 * @tc.name   : testAllocateBuffer001
 * @tc.desc   : Set component status to CODEC_State_IDLE, portIndex=INPUT_INDEX,command was successfully sent.
 */
HWTEST_F(CodecComponentTestAdditional, testAllocateBuffer001, Function | MediumTest | Level1)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    auto err = g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_IDLE, cmdData);
    ASSERT_EQ(err, HDF_SUCCESS);

    struct OmxCodecBuffer allocBuffer;
    InitOmxCodecBuffer(allocBuffer, CODEC_BUFFER_TYPE_AVSHARE_MEM_FD);
    struct OmxCodecBuffer outBuffer;
    err = g_component->AllocateBuffer(INPUT_INDEX, allocBuffer, outBuffer);
    ASSERT_EQ(err, HDF_SUCCESS);
    err = g_component->FreeBuffer(INPUT_INDEX, outBuffer);
    ASSERT_EQ(err, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_AllocateBuffer_0300
 * @tc.name   : testAllocateBuffer002
 * @tc.desc   : Set component status to CODEC_State_IDLE, portIndex=INPUT_INDEX,
 *              The structure OmxCodecBuffer->bufferId=0,command was successfully sent.
 */
HWTEST_F(CodecComponentTestAdditional, testAllocateBuffer002, Function | MediumTest | Level1)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    auto err = g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_IDLE, cmdData);
    ASSERT_EQ(err, HDF_SUCCESS);

    struct OmxCodecBuffer allocBuffer;
    InitOmxCodecBuffer(allocBuffer, CODEC_BUFFER_TYPE_AVSHARE_MEM_FD);
    allocBuffer.bufferId = 0;
    struct OmxCodecBuffer outBuffer;
    err = g_component->AllocateBuffer(INPUT_INDEX, allocBuffer, outBuffer);
    ASSERT_EQ(err, HDF_SUCCESS);
    err = g_component->FreeBuffer(INPUT_INDEX, outBuffer);
    ASSERT_EQ(err, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_AllocateBuffer_0400
 * @tc.name   : testAllocateBuffer003
 * @tc.desc   : Set component status to CODEC_STATE_LOADED, portIndex=INPUT_INDEX,command was successfully sent.
 */
HWTEST_F(CodecComponentTestAdditional, testAllocateBuffer003, Function | MediumTest | Level1)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    auto err = g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_LOADED, cmdData);
    ASSERT_EQ(err, HDF_SUCCESS);

    struct OmxCodecBuffer allocBuffer;
    InitOmxCodecBuffer(allocBuffer, CODEC_BUFFER_TYPE_AVSHARE_MEM_FD);
    struct OmxCodecBuffer outBuffer;
    err = g_component->AllocateBuffer(INPUT_INDEX, allocBuffer, outBuffer);
#ifdef DISPLAY_COMMUNITY
    ASSERT_EQ(err, HDF_SUCCESS);
#else
    ASSERT_NE(err, HDF_SUCCESS);
#endif
    err = g_component->FreeBuffer(INPUT_INDEX, outBuffer);
#ifdef DISPLAY_COMMUNITY
    ASSERT_EQ(err, HDF_SUCCESS);
#else
    ASSERT_NE(err, HDF_SUCCESS);
#endif
}
/**
 * @tc.number : SUB_Driver_Codec_AllocateBuffer_0500
 * @tc.name   : testAllocateBuffer004
 * @tc.desc   : Set component status to CODEC_STATE_IDLE, portIndex=OUTPUT_INDEX,command was successfully sent.
 */
HWTEST_F(CodecComponentTestAdditional, testAllocateBuffer004, Function | MediumTest | Level1)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    auto err = g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_IDLE, cmdData);
    ASSERT_EQ(err, HDF_SUCCESS);

    struct OmxCodecBuffer allocBuffer;
    InitOmxCodecBuffer(allocBuffer, CODEC_BUFFER_TYPE_AVSHARE_MEM_FD);
    struct OmxCodecBuffer outBuffer;
    err = g_component->AllocateBuffer(OUTPUT_INDEX, allocBuffer, outBuffer);
    ASSERT_EQ(err, HDF_SUCCESS);
    err = g_component->FreeBuffer(OUTPUT_INDEX, outBuffer);
    ASSERT_EQ(err, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_FreeBuffer_0200
 * @tc.name   : testFreeBuffer001
 * @tc.desc   : When the function is called directly for release, sending the command fails.
 */
HWTEST_F(CodecComponentTestAdditional, testFreeBuffer001, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    struct OmxCodecBuffer omxBuffer;
    InitOmxCodecBuffer(omxBuffer, CODEC_BUFFER_TYPE_AVSHARE_MEM_FD);
    auto ret = g_component->FreeBuffer(OUTPUT_INDEX, omxBuffer);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_FreeBuffer_0300
 * @tc.name   : testFreeBuffer002
 * @tc.desc   : Set the component status to OMX first_ StateLoaded, call the AllocateBuffer function to apply for space,
 *              then call the FreeBuffer function,send the command successfully.
 */
HWTEST_F(CodecComponentTestAdditional, testFreeBuffer002, Function | MediumTest | Level1)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    auto err = g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_IDLE, cmdData);
    ASSERT_EQ(err, HDF_SUCCESS);

    struct OmxCodecBuffer allocBuffer;
    InitOmxCodecBuffer(allocBuffer, CODEC_BUFFER_TYPE_AVSHARE_MEM_FD);
    struct OmxCodecBuffer outBuffer;
    err = g_component->AllocateBuffer(INPUT_INDEX, allocBuffer, outBuffer);
    ASSERT_EQ(err, HDF_SUCCESS);
    err = g_component->FreeBuffer(INPUT_INDEX, outBuffer);
    ASSERT_EQ(err, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_FreeBuffer_0400
 * @tc.name   : testFreeBuffer003
 * @tc.desc   : Structure OmxCodecBuffer->bufferId = BUFFER_ID_ERROR, sending command failed
 */
HWTEST_F(CodecComponentTestAdditional, testFreeBuffer003, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    auto err = g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_IDLE, cmdData);
    ASSERT_EQ(err, HDF_SUCCESS);

    struct OmxCodecBuffer allocBuffer;
    InitOmxCodecBuffer(allocBuffer, CODEC_BUFFER_TYPE_AVSHARE_MEM_FD);
    struct OmxCodecBuffer outBuffer;
    err = g_component->AllocateBuffer(INPUT_INDEX, allocBuffer, outBuffer);
    ASSERT_EQ(err, HDF_SUCCESS);
    outBuffer.bufferId = BUFFER_ID_ERROR;
    err = g_component->FreeBuffer(INPUT_INDEX, outBuffer);
    ASSERT_NE(err, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_FreeBuffer_0500
 * @tc.name   : testFreeBuffer004
 * @tc.desc   : Structure OmxCodecBuffer->size = 0, sending command success
 */
HWTEST_F(CodecComponentTestAdditional, testFreeBuffer004, Function | MediumTest | Level1)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    auto err = g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_IDLE, cmdData);
    ASSERT_EQ(err, HDF_SUCCESS);

    struct OmxCodecBuffer allocBuffer;
    InitOmxCodecBuffer(allocBuffer, CODEC_BUFFER_TYPE_AVSHARE_MEM_FD);
    struct OmxCodecBuffer outBuffer;
    err = g_component->AllocateBuffer(INPUT_INDEX, allocBuffer, outBuffer);
    ASSERT_EQ(err, HDF_SUCCESS);
    outBuffer.size = 0;
    err = g_component->FreeBuffer(INPUT_INDEX, outBuffer);
    ASSERT_EQ(err, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_FreeBuffer_0600
 * @tc.name   : testFreeBuffer005
 * @tc.desc   : Structure OmxCodecBuffer->bufferType=CODEC_BUFFER_TYPE_AVSHARE_MEM_FD,command sent successfully.
 */
HWTEST_F(CodecComponentTestAdditional, testFreeBuffer005, Function | MediumTest | Level1)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    auto err = g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_IDLE, cmdData);
    ASSERT_EQ(err, HDF_SUCCESS);

    struct OmxCodecBuffer allocBuffer;
    InitOmxCodecBuffer(allocBuffer, CODEC_BUFFER_TYPE_AVSHARE_MEM_FD);
    struct OmxCodecBuffer outBuffer;
    err = g_component->AllocateBuffer(INPUT_INDEX, allocBuffer, outBuffer);
    ASSERT_EQ(err, HDF_SUCCESS);
    outBuffer.bufferType = CODEC_BUFFER_TYPE_AVSHARE_MEM_FD;
    err = g_component->FreeBuffer(INPUT_INDEX, outBuffer);
    ASSERT_EQ(err, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_FreeBuffer_0700
 * @tc.name   : testFreeBuffer006
 * @tc.desc   : The structure OmxCodecBuffer->allocLen = 0,the command was successfully sent.
 */
HWTEST_F(CodecComponentTestAdditional, testFreeBuffer006, Function | MediumTest | Level1)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    auto err = g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_IDLE, cmdData);
    ASSERT_EQ(err, HDF_SUCCESS);

    struct OmxCodecBuffer allocBuffer;
    InitOmxCodecBuffer(allocBuffer, CODEC_BUFFER_TYPE_AVSHARE_MEM_FD);
    struct OmxCodecBuffer outBuffer;
    err = g_component->AllocateBuffer(INPUT_INDEX, allocBuffer, outBuffer);
    ASSERT_EQ(err, HDF_SUCCESS);
    outBuffer.allocLen = 0;
    err = g_component->FreeBuffer(INPUT_INDEX, outBuffer);
    ASSERT_EQ(err, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_FreeBuffer_0800
 * @tc.name   : testFreeBuffer007
 * @tc.desc   : The structure OmxCodecBuffer->filledLen = 0,the command was successfully sent.
 */
HWTEST_F(CodecComponentTestAdditional, testFreeBuffer007, Function | MediumTest | Level1)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    auto err = g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_IDLE, cmdData);
    ASSERT_EQ(err, HDF_SUCCESS);

    struct OmxCodecBuffer allocBuffer;
    InitOmxCodecBuffer(allocBuffer, CODEC_BUFFER_TYPE_AVSHARE_MEM_FD);
    struct OmxCodecBuffer outBuffer;
    err = g_component->AllocateBuffer(INPUT_INDEX, allocBuffer, outBuffer);
    ASSERT_EQ(err, HDF_SUCCESS);
    outBuffer.filledLen = 0;
    err = g_component->FreeBuffer(INPUT_INDEX, outBuffer);
    ASSERT_EQ(err, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_FreeBuffer_0900
 * @tc.name   : testFreeBuffer008
 * @tc.desc   : The structure OmxCodecBuffer->type = READ_WRITE_TYPE,the command was successfully sent.
 */
HWTEST_F(CodecComponentTestAdditional, testFreeBuffer008, Function | MediumTest | Level1)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    auto err = g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_IDLE, cmdData);
    ASSERT_EQ(err, HDF_SUCCESS);

    struct OmxCodecBuffer allocBuffer;
    InitOmxCodecBuffer(allocBuffer, CODEC_BUFFER_TYPE_AVSHARE_MEM_FD);
    struct OmxCodecBuffer outBuffer;
    err = g_component->AllocateBuffer(INPUT_INDEX, allocBuffer, outBuffer);
    ASSERT_EQ(err, HDF_SUCCESS);
    outBuffer.type = READ_WRITE_TYPE;
    err = g_component->FreeBuffer(INPUT_INDEX, outBuffer);
    ASSERT_EQ(err, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_FreeBuffer_1000
 * @tc.name   : testFreeBuffer009
 * @tc.desc   : The structure OmxCodecBuffer->type = READ_ONLY_TYPE,the command was successfully sent.
 */
HWTEST_F(CodecComponentTestAdditional, testFreeBuffer009, Function | MediumTest | Level1)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    auto err = g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_IDLE, cmdData);
    ASSERT_EQ(err, HDF_SUCCESS);

    struct OmxCodecBuffer allocBuffer;
    InitOmxCodecBuffer(allocBuffer, CODEC_BUFFER_TYPE_AVSHARE_MEM_FD);
    struct OmxCodecBuffer outBuffer;
    err = g_component->AllocateBuffer(INPUT_INDEX, allocBuffer, outBuffer);
    ASSERT_EQ(err, HDF_SUCCESS);
    outBuffer.type = READ_ONLY_TYPE;
    err = g_component->FreeBuffer(INPUT_INDEX, outBuffer);
    ASSERT_EQ(err, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_FreeBuffer_1100
 * @tc.name   : testFreeBuffer010
 * @tc.desc   : Set the component status to OMX_StateExecuting
 */
HWTEST_F(CodecComponentTestAdditional, testFreeBuffer010, Function | MediumTest | Level1)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    auto err = g_component->SendCommand(CODEC_COMMAND_STATE_SET, OMX_StateExecuting, cmdData);
    ASSERT_EQ(err, HDF_SUCCESS);

    struct OmxCodecBuffer allocBuffer;
    InitOmxCodecBuffer(allocBuffer, CODEC_BUFFER_TYPE_AVSHARE_MEM_FD);
    struct OmxCodecBuffer outBuffer;
    err = g_component->AllocateBuffer(INPUT_INDEX, allocBuffer, outBuffer);
#ifdef DISPLAY_COMMUNITY
    ASSERT_EQ(err, HDF_SUCCESS);
#else
    ASSERT_NE(err, HDF_SUCCESS);
#endif
    err = g_component->FreeBuffer(INPUT_INDEX, outBuffer);
#ifdef DISPLAY_COMMUNITY
    ASSERT_EQ(err, HDF_SUCCESS);
#else
    ASSERT_NE(err, HDF_SUCCESS);
#endif
}
/**
 * @tc.number : SUB_Driver_Codec_EmptyThisBuffer_0200
 * @tc.name   : testEmptyThisBuffer001
 * @tc.desc   : Set the component status to OMX_StateLoaded
 */
HWTEST_F(CodecComponentTestAdditional, testEmptyThisBuffer001, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    auto err = g_component->SendCommand(CODEC_COMMAND_STATE_SET, OMX_StateLoaded, cmdData);
    ASSERT_EQ(err, HDF_SUCCESS);
    struct OmxCodecBuffer omxBuffer;
    InitOmxCodecBuffer(omxBuffer, CODEC_BUFFER_TYPE_AVSHARE_MEM_FD);
    auto ret = g_component->EmptyThisBuffer(omxBuffer);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_EmptyThisBuffer_0300
 * @tc.name   : testEmptyThisBuffer002
 * @tc.desc   : Set component status to OMX_StateExecuting, structure OmxCodecBuffer->bufferId=BUFFER_ID_ERROR
 */
HWTEST_F(CodecComponentTestAdditional, testEmptyThisBuffer002, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    auto err = g_component->SendCommand(CODEC_COMMAND_STATE_SET, OMX_StateExecuting, cmdData);
    ASSERT_EQ(err, HDF_SUCCESS);
    struct OmxCodecBuffer omxBuffer;
    InitOmxCodecBuffer(omxBuffer, CODEC_BUFFER_TYPE_AVSHARE_MEM_FD);
    omxBuffer.bufferId = BUFFER_ID_ERROR;
    auto ret = g_component->EmptyThisBuffer(omxBuffer);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_EmptyThisBuffer_0400
 * @tc.name   : testEmptyThisBuffer003
 * @tc.desc   : Set component status to OMX_StateIdle
 */
HWTEST_F(CodecComponentTestAdditional, testEmptyThisBuffer003, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    auto err = g_component->SendCommand(CODEC_COMMAND_STATE_SET, OMX_StateIdle, cmdData);
    ASSERT_EQ(err, HDF_SUCCESS);
    struct OmxCodecBuffer omxBuffer;
    InitOmxCodecBuffer(omxBuffer, CODEC_BUFFER_TYPE_AVSHARE_MEM_FD);
    auto ret = g_component->EmptyThisBuffer(omxBuffer);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_EmptyThisBuffer_0500
 * @tc.name   : testEmptyThisBuffer004
 * @tc.desc   : Set component status to OMX_StateInvalid
 */
HWTEST_F(CodecComponentTestAdditional, testEmptyThisBuffer004, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    auto err = g_component->SendCommand(CODEC_COMMAND_STATE_SET, OMX_StateInvalid, cmdData);
    ASSERT_EQ(err, HDF_SUCCESS);
    struct OmxCodecBuffer omxBuffer;
    InitOmxCodecBuffer(omxBuffer, CODEC_BUFFER_TYPE_AVSHARE_MEM_FD);
    auto ret = g_component->EmptyThisBuffer(omxBuffer);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_EmptyThisBuffer_0600
 * @tc.name   : testEmptyThisBuffer005
 * @tc.desc   : Set component status to OMX_StateWaitForResources
 */
HWTEST_F(CodecComponentTestAdditional, testEmptyThisBuffer005, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    auto err = g_component->SendCommand(CODEC_COMMAND_STATE_SET, OMX_StateWaitForResources, cmdData);
    ASSERT_EQ(err, HDF_SUCCESS);
    struct OmxCodecBuffer omxBuffer;
    InitOmxCodecBuffer(omxBuffer, CODEC_BUFFER_TYPE_AVSHARE_MEM_FD);
    auto ret = g_component->EmptyThisBuffer(omxBuffer);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_FillThisBuffer_0200
 * @tc.name   : testFillThisBuffer001
 * @tc.desc   : Set component status to OMX_StatePause,structure OmxCodecBuffer->bufferType=CODEC_BUFFER_TYPE_INVALID
 */
HWTEST_F(CodecComponentTestAdditional, testFillThisBuffer001, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    auto err = g_component->SendCommand(CODEC_COMMAND_STATE_SET, OMX_StatePause, cmdData);
    ASSERT_EQ(err, HDF_SUCCESS);
    struct OmxCodecBuffer omxBuffer;
    InitOmxCodecBuffer(omxBuffer, CODEC_BUFFER_TYPE_AVSHARE_MEM_FD);
    omxBuffer.bufferType = CODEC_BUFFER_TYPE_INVALID;
    auto ret = g_component->FillThisBuffer(omxBuffer);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_FillThisBuffer_0300
 * @tc.name   : testFillThisBuffer002
 * @tc.desc   : Set component status to OMX_StateExecuting,
 *              structure OmxCodecBuffer->bufferType=CODEC_BUFFER_TYPE_INVALID
 */
HWTEST_F(CodecComponentTestAdditional, testFillThisBuffer002, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    auto err = g_component->SendCommand(CODEC_COMMAND_STATE_SET, OMX_StateExecuting, cmdData);
    ASSERT_EQ(err, HDF_SUCCESS);
    struct OmxCodecBuffer omxBuffer;
    InitOmxCodecBuffer(omxBuffer, CODEC_BUFFER_TYPE_AVSHARE_MEM_FD);
    omxBuffer.bufferType = CODEC_BUFFER_TYPE_INVALID;
    auto ret = g_component->FillThisBuffer(omxBuffer);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_FillThisBuffer_0400
 * @tc.name   : testFillThisBuffer003
 * @tc.desc   : Set component status to OMX_StateExecution, structure OmxCodecBuffer->size=0
 */
HWTEST_F(CodecComponentTestAdditional, testFillThisBuffer003, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    auto err = g_component->SendCommand(CODEC_COMMAND_STATE_SET, OMX_StateExecuting, cmdData);
    ASSERT_EQ(err, HDF_SUCCESS);
    struct OmxCodecBuffer omxBuffer;
    InitOmxCodecBuffer(omxBuffer, CODEC_BUFFER_TYPE_AVSHARE_MEM_FD);
    omxBuffer.size = 0;
    auto ret = g_component->FillThisBuffer(omxBuffer);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_FillThisBuffer_0500
 * @tc.name   : testFillThisBuffer004
 * @tc.desc   : Set component status to OMX_StateExecution, structure OmxCodecBuffer->bufferId = BUFFER_ID_ERROR
 */
HWTEST_F(CodecComponentTestAdditional, testFillThisBuffer004, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    auto err = g_component->SendCommand(CODEC_COMMAND_STATE_SET, OMX_StateExecuting, cmdData);
    ASSERT_EQ(err, HDF_SUCCESS);
    struct OmxCodecBuffer omxBuffer;
    InitOmxCodecBuffer(omxBuffer, CODEC_BUFFER_TYPE_AVSHARE_MEM_FD);
    omxBuffer.bufferId = BUFFER_ID_ERROR;
    auto ret = g_component->FillThisBuffer(omxBuffer);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_FillThisBuffer_0600
 * @tc.name   : testFillThisBuffer005
 * @tc.desc   : Set component status to OMX_StateIdle
 */
HWTEST_F(CodecComponentTestAdditional, testFillThisBuffer005, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    auto err = g_component->SendCommand(CODEC_COMMAND_STATE_SET, OMX_StateIdle, cmdData);
    ASSERT_EQ(err, HDF_SUCCESS);
    struct OmxCodecBuffer omxBuffer;
    InitOmxCodecBuffer(omxBuffer, CODEC_BUFFER_TYPE_AVSHARE_MEM_FD);
    auto ret = g_component->FillThisBuffer(omxBuffer);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_ComponentDeInit_0200
 * @tc.name   : testComponentDeInit001
 * @tc.desc   : When directly calling the ComponentDeInit function, the command was successfully sent.
 */
HWTEST_F(CodecComponentTestAdditional, testComponentDeInit001, Function | MediumTest | Level1)
{
    ASSERT_TRUE(g_component != nullptr);
    auto ret = g_component->ComponentDeInit();
    ASSERT_EQ(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_ComponentDeInit_0300
 * @tc.name   : testComponentDeInit002
 * @tc.desc   : Set the condition to OMX_StateLoaded, the command was successfully sent.
 */
HWTEST_F(CodecComponentTestAdditional, testComponentDeInit002, Function | MediumTest | Level1)
{
    ASSERT_TRUE(g_component != nullptr);
    OMX_STATETYPE status = OMX_StateLoaded;
    std::cout << "status = " << status << std::endl;
    auto ret = g_component->ComponentDeInit();
    ASSERT_EQ(ret, HDF_SUCCESS);
}
#ifdef SUPPORT_OMX
/**
 * @tc.number : SUB_Driver_Codec_ComponentRoleEnum_0200
 * @tc.name   : testComponentRoleEnum001
 * @tc.desc   : When index=0, the command was successfully sent.
 */
HWTEST_F(CodecComponentTestAdditional, testComponentRoleEnum001, Function | MediumTest | Level1)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<uint8_t> role;
    auto ret = g_component->ComponentRoleEnum(role, 0);
    ASSERT_EQ(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_ComponentRoleEnum_0300
 * @tc.name   : testComponentRoleEnum002
 * @tc.desc   : When index=65000, sending command failed
 */
HWTEST_F(CodecComponentTestAdditional, testComponentRoleEnum002, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<uint8_t> role;
    auto ret = g_component->ComponentRoleEnum(role, 65000);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_UseEglImage_0200
 * @tc.name   : testUseEglImage001
 * @tc.desc   : Initialize the structure OmxCodecBuffer with portIndex=INPUT_INDEX, sending command failed.
 */
HWTEST_F(CodecComponentTestAdditional, testUseEglImage001, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    struct OmxCodecBuffer omxBuffer;
    InitOmxCodecBuffer(omxBuffer, CODEC_BUFFER_TYPE_AVSHARE_MEM_FD);
    auto eglImage = std::make_unique<int8_t[]>(BUFFER_SIZE);
    ASSERT_TRUE(eglImage != nullptr);
    std::vector<int8_t> eglImageVec;
    eglImageVec.assign(eglImage.get(), eglImage.get() + BUFFER_SIZE);
    struct OmxCodecBuffer outbuffer;
    int32_t ret = g_component->UseEglImage(INPUT_INDEX, omxBuffer, outbuffer, eglImageVec);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_UseEglImage_0300
 * @tc.name   : testUseEglImage002
 * @tc.desc   : Set component status to OMX_StatePause, portIndex=INPUT_INDEX, sending command failed.
 */
HWTEST_F(CodecComponentTestAdditional, testUseEglImage002, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    struct OmxCodecBuffer omxBuffer;
    OMX_STATETYPE status = OMX_StatePause;
    std::cout << "status = " << status << std::endl;
    InitOmxCodecBuffer(omxBuffer, CODEC_BUFFER_TYPE_AVSHARE_MEM_FD);
    auto eglImage = std::make_unique<int8_t[]>(BUFFER_SIZE);
    ASSERT_TRUE(eglImage != nullptr);
    std::vector<int8_t> eglImageVec;
    eglImageVec.assign(eglImage.get(), eglImage.get() + BUFFER_SIZE);
    struct OmxCodecBuffer outbuffer;
    int32_t ret = g_component->UseEglImage(INPUT_INDEX, omxBuffer, outbuffer, eglImageVec);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_UseEglImage_0400
 * @tc.name   : testUseEglImage003
 * @tc.desc   : Set component status to OMX_StateLoaded, portIndex=INPUT_INDEX, sending command failed.
 */
HWTEST_F(CodecComponentTestAdditional, testUseEglImage003, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    struct OmxCodecBuffer omxBuffer;
    OMX_STATETYPE status = OMX_StateLoaded;
    std::cout << "status = " << status << std::endl;
    InitOmxCodecBuffer(omxBuffer, CODEC_BUFFER_TYPE_AVSHARE_MEM_FD);
    auto eglImage = std::make_unique<int8_t[]>(BUFFER_SIZE);
    ASSERT_TRUE(eglImage != nullptr);
    std::vector<int8_t> eglImageVec;
    eglImageVec.assign(eglImage.get(), eglImage.get() + BUFFER_SIZE);
    struct OmxCodecBuffer outbuffer;
    int32_t ret = g_component->UseEglImage(INPUT_INDEX, omxBuffer, outbuffer, eglImageVec);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_UseEglImage_0500
 * @tc.name   : testUseEglImage004
 * @tc.desc   : Set component status to OMX_StateWaitForResources, portIndex=INPUT_INDEX, sending command failed.
 */
HWTEST_F(CodecComponentTestAdditional, testUseEglImage004, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    struct OmxCodecBuffer omxBuffer;
    auto ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, OMX_StateWaitForResources, cmdData);
    InitOmxCodecBuffer(omxBuffer, CODEC_BUFFER_TYPE_AVSHARE_MEM_FD);
    auto eglImage = std::make_unique<int8_t[]>(BUFFER_SIZE);
    ASSERT_TRUE(eglImage != nullptr);
    std::vector<int8_t> eglImageVec;
    eglImageVec.assign(eglImage.get(), eglImage.get() + BUFFER_SIZE);
    struct OmxCodecBuffer outbuffer;
    ret = g_component->UseEglImage(INPUT_INDEX, omxBuffer, outbuffer, eglImageVec);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_UseEglImage_0600
 * @tc.name   : testUseEglImage005
 * @tc.desc   : Set component status to OMX_StateExecuting, portIndex=INPUT_INDEX, sending command failed.
 */
HWTEST_F(CodecComponentTestAdditional, testUseEglImage005, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    struct OmxCodecBuffer omxBuffer;
    auto ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, OMX_StateExecuting, cmdData);
    InitOmxCodecBuffer(omxBuffer, CODEC_BUFFER_TYPE_AVSHARE_MEM_FD);
    auto eglImage = std::make_unique<int8_t[]>(BUFFER_SIZE);
    ASSERT_TRUE(eglImage != nullptr);
    std::vector<int8_t> eglImageVec;
    eglImageVec.assign(eglImage.get(), eglImage.get() + BUFFER_SIZE);
    struct OmxCodecBuffer outbuffer;
    ret = g_component->UseEglImage(INPUT_INDEX, omxBuffer, outbuffer, eglImageVec);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_UseEglImage_0700
 * @tc.name   : testUseEglImage006
 * @tc.desc   : Set component status to OMX_StateLoaded, with CODEC_BUFFER_TYPE_VIRTUAL_ADDR.
 */
HWTEST_F(CodecComponentTestAdditional, testUseEglImage006, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    struct OmxCodecBuffer omxBuffer;
    auto ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, OMX_StateLoaded, cmdData);
    InitOmxCodecBuffer(omxBuffer, CODEC_BUFFER_TYPE_VIRTUAL_ADDR);
    auto eglImage = std::make_unique<int8_t[]>(BUFFER_SIZE);
    ASSERT_TRUE(eglImage != nullptr);
    std::vector<int8_t> eglImageVec;
    eglImageVec.assign(eglImage.get(), eglImage.get() + BUFFER_SIZE);
    struct OmxCodecBuffer outbuffer;
    ret = g_component->UseEglImage(INPUT_INDEX, omxBuffer, outbuffer, eglImageVec);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_UseEglImage_0800
 * @tc.name   : testUseEglImage007
 * @tc.desc   : Set component status to OMX_StateExecuting, with CODEC_BUFFER_TYPE_VIRTUAL_ADDR
 */
HWTEST_F(CodecComponentTestAdditional, testUseEglImage007, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    struct OmxCodecBuffer omxBuffer;
    auto ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, OMX_StateExecuting, cmdData);
    InitOmxCodecBuffer(omxBuffer, CODEC_BUFFER_TYPE_VIRTUAL_ADDR);
    auto eglImage = std::make_unique<int8_t[]>(BUFFER_SIZE);
    ASSERT_TRUE(eglImage != nullptr);
    std::vector<int8_t> eglImageVec;
    eglImageVec.assign(eglImage.get(), eglImage.get() + BUFFER_SIZE);
    struct OmxCodecBuffer outbuffer;
    ret = g_component->UseEglImage(INPUT_INDEX, omxBuffer, outbuffer, eglImageVec);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_UseEglImage_0900
 * @tc.name   : testUseEglImage008
 * @tc.desc   : Set component status to OMX_StateWaitForResources, with CODEC_BUFFER_TYPE_HANDLE
 */
HWTEST_F(CodecComponentTestAdditional, testUseEglImage008, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    struct OmxCodecBuffer omxBuffer;
    auto ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, OMX_StateWaitForResources, cmdData);
    InitOmxCodecBuffer(omxBuffer, CODEC_BUFFER_TYPE_HANDLE);
    auto eglImage = std::make_unique<int8_t[]>(BUFFER_SIZE);
    ASSERT_TRUE(eglImage != nullptr);
    std::vector<int8_t> eglImageVec;
    eglImageVec.assign(eglImage.get(), eglImage.get() + BUFFER_SIZE);
    struct OmxCodecBuffer outbuffer;
    ret = g_component->UseEglImage(INPUT_INDEX, omxBuffer, outbuffer, eglImageVec);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_UseEglImage_1000
 * @tc.name   : testUseEglImage009
 * @tc.desc   : Set component status to OMX_StateLoaded, with CODEC_BUFFER_TYPE_DYNAMIC_HANDLE
 */
HWTEST_F(CodecComponentTestAdditional, testUseEglImage009, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    struct OmxCodecBuffer omxBuffer;
    auto ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, OMX_StateLoaded, cmdData);
    InitOmxCodecBuffer(omxBuffer, CODEC_BUFFER_TYPE_DYNAMIC_HANDLE);
    auto eglImage = std::make_unique<int8_t[]>(BUFFER_SIZE);
    ASSERT_TRUE(eglImage != nullptr);
    std::vector<int8_t> eglImageVec;
    eglImageVec.assign(eglImage.get(), eglImage.get() + BUFFER_SIZE);
    struct OmxCodecBuffer outbuffer;
    ret = g_component->UseEglImage(INPUT_INDEX, omxBuffer, outbuffer, eglImageVec);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_UseEglImage_1100
 * @tc.name   : testUseEglImage010
 * @tc.desc   : Initialize the structure OmxCodecBuffer with portIndex=OUTPUT_INDEX, sending command failed.
 */
HWTEST_F(CodecComponentTestAdditional, testUseEglImage010, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    struct OmxCodecBuffer omxBuffer;
    InitOmxCodecBuffer(omxBuffer, CODEC_BUFFER_TYPE_AVSHARE_MEM_FD);
    auto eglImage = std::make_unique<int8_t[]>(BUFFER_SIZE);
    ASSERT_TRUE(eglImage != nullptr);
    std::vector<int8_t> eglImageVec;
    eglImageVec.assign(eglImage.get(), eglImage.get() + BUFFER_SIZE);
    struct OmxCodecBuffer outbuffer;
    int32_t ret = g_component->UseEglImage(OUTPUT_INDEX, omxBuffer, outbuffer, eglImageVec);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_UseEglImage_1200
 * @tc.name   : testUseEglImage011
 * @tc.desc   : Set component status to OMX_StatePause, portIndex=OUTPUT_INDEX, sending command failed.
 */
HWTEST_F(CodecComponentTestAdditional, testUseEglImage011, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    struct OmxCodecBuffer omxBuffer;
    OMX_STATETYPE status = OMX_StatePause;
    std::cout << "status = " << status << std::endl;
    InitOmxCodecBuffer(omxBuffer, CODEC_BUFFER_TYPE_AVSHARE_MEM_FD);
    auto eglImage = std::make_unique<int8_t[]>(BUFFER_SIZE);
    ASSERT_TRUE(eglImage != nullptr);
    std::vector<int8_t> eglImageVec;
    eglImageVec.assign(eglImage.get(), eglImage.get() + BUFFER_SIZE);
    struct OmxCodecBuffer outbuffer;
    int32_t ret = g_component->UseEglImage(OUTPUT_INDEX, omxBuffer, outbuffer, eglImageVec);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_UseEglImage_1300
 * @tc.name   : testUseEglImage012
 * @tc.desc   : Set component status to OMX_StateLoaded, portIndex=OUTPUT_INDEX, sending command failed.
 */
HWTEST_F(CodecComponentTestAdditional, testUseEglImage012, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    struct OmxCodecBuffer omxBuffer;
    OMX_STATETYPE status = OMX_StateLoaded;
    std::cout << "status = " << status << std::endl;
    InitOmxCodecBuffer(omxBuffer, CODEC_BUFFER_TYPE_AVSHARE_MEM_FD);
    auto eglImage = std::make_unique<int8_t[]>(BUFFER_SIZE);
    ASSERT_TRUE(eglImage != nullptr);
    std::vector<int8_t> eglImageVec;
    eglImageVec.assign(eglImage.get(), eglImage.get() + BUFFER_SIZE);
    struct OmxCodecBuffer outbuffer;
    int32_t ret = g_component->UseEglImage(OUTPUT_INDEX, omxBuffer, outbuffer, eglImageVec);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_UseEglImage_1400
 * @tc.name   : testUseEglImage013
 * @tc.desc   : Set component status to OMX_StateWaitForResources, portIndex=OUTPUT_INDEX, sending command failed.
 */
HWTEST_F(CodecComponentTestAdditional, testUseEglImage013, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    struct OmxCodecBuffer omxBuffer;
    auto ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, OMX_StateWaitForResources, cmdData);
    InitOmxCodecBuffer(omxBuffer, CODEC_BUFFER_TYPE_AVSHARE_MEM_FD);
    auto eglImage = std::make_unique<int8_t[]>(BUFFER_SIZE);
    ASSERT_TRUE(eglImage != nullptr);
    std::vector<int8_t> eglImageVec;
    eglImageVec.assign(eglImage.get(), eglImage.get() + BUFFER_SIZE);
    struct OmxCodecBuffer outbuffer;
    ret = g_component->UseEglImage(OUTPUT_INDEX, omxBuffer, outbuffer, eglImageVec);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_UseEglImage_1500
 * @tc.name   : testUseEglImage014
 * @tc.desc   : Set component status to OMX_StateExecuting, portIndex=OUTPUT_INDEX, sending command failed.
 */
HWTEST_F(CodecComponentTestAdditional, testUseEglImage014, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    struct OmxCodecBuffer omxBuffer;
    auto ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, OMX_StateExecuting, cmdData);
    InitOmxCodecBuffer(omxBuffer, CODEC_BUFFER_TYPE_AVSHARE_MEM_FD);
    auto eglImage = std::make_unique<int8_t[]>(BUFFER_SIZE);
    ASSERT_TRUE(eglImage != nullptr);
    std::vector<int8_t> eglImageVec;
    eglImageVec.assign(eglImage.get(), eglImage.get() + BUFFER_SIZE);
    struct OmxCodecBuffer outbuffer;
    ret = g_component->UseEglImage(OUTPUT_INDEX, omxBuffer, outbuffer, eglImageVec);
    ASSERT_NE(ret, HDF_SUCCESS);
}
#endif
/**
 * @tc.number : SUB_Driver_Codec_SetCallbacks_0200
 * @tc.name   : testSetCallbacks001
 * @tc.desc   : Set the function entry to appData = -1
 */
HWTEST_F(CodecComponentTestAdditional, testSetCallbacks001, Function | MediumTest | Level1)
{
    ASSERT_TRUE(g_component != nullptr);
    g_callback = new CodecCallbackService();
    ASSERT_TRUE(g_callback != nullptr);
    auto ret = g_component->SetCallbacks(g_callback, -1);
    ASSERT_EQ(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_SetCallbacks_0300
 * @tc.name   : testSetCallbacks002
 * @tc.desc   : Set the function entry to appData = 0
 */
HWTEST_F(CodecComponentTestAdditional, testSetCallbacks002, Function | MediumTest | Level1)
{
    ASSERT_TRUE(g_component != nullptr);
    g_callback = new CodecCallbackService();
    ASSERT_TRUE(g_callback != nullptr);
    auto ret = g_component->SetCallbacks(g_callback, 0);
    ASSERT_EQ(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_SetCallbacks_0400
 * @tc.name   : testSetCallbacks003
 * @tc.desc   : Set the function entry to appData = 1000
 */
HWTEST_F(CodecComponentTestAdditional, testSetCallbacks003, Function | MediumTest | Level1)
{
    ASSERT_TRUE(g_component != nullptr);
    g_callback = new CodecCallbackService();
    ASSERT_TRUE(g_callback != nullptr);
    auto ret = g_component->SetCallbacks(g_callback, 1000);
    ASSERT_EQ(ret, HDF_SUCCESS);
}
/**
 * @tc.number : SUB_Driver_Codec_SetCallbacks_0500
 * @tc.name   : testSetCallbacks004
 * @tc.desc   : Set the function entry to appData = 1 and cycle 100 times
 */
HWTEST_F(CodecComponentTestAdditional, testSetCallbacks004, Function | MediumTest | Level1)
{
    int32_t i = 0;
    int32_t ret;
    ASSERT_TRUE(g_component != nullptr);
    g_callback = new CodecCallbackService();
    ASSERT_TRUE(g_callback != nullptr);
    for (i = 0; i < 100; i++) {
        ret = g_component->SetCallbacks(g_callback, 1);
        ASSERT_EQ(ret, HDF_SUCCESS);
    }
}
/**
 * @tc.number  SUB_Driver_Codec_GetComponentVersion_0100
 * @tc.name  testGetComponentVersion001
 * @tc.desc  The input parameter is empty.
 */
HWTEST_F(CodecComponentTestAdditional, testGetComponentVersion001, Function | MediumTest | Level1)
{
    ASSERT_TRUE(g_component != nullptr);
    struct CompVerInfo verInfo;
    auto ret = g_component->GetComponentVersion(verInfo);
    ASSERT_EQ(ret, HDF_SUCCESS);
}
/**
 * @tc.number  SUB_Driver_Codec_SendCommand_0100
 * @tc.name  testSendCommand001
 * @tc.desc  The first and second parameters are CODEC_COMMAND_STATE_SET and CODEC_STATE_INVALID. SendCommand is
 * successful.
 */
HWTEST_F(CodecComponentTestAdditional, testSendCommand001, Function | MediumTest | Level1)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    int32_t ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_INVALID, cmdData);
    ASSERT_EQ(ret, HDF_SUCCESS);
}
/**
 * @tc.number  SUB_Driver_Codec_SendCommand_0200
 * @tc.name  testSendCommand002
 * @tc.desc  The first and second parameters are CODEC_COMMAND_STATE_SET and CODEC_STATE_LOADED. SendCommand is
 * successful.
 */
HWTEST_F(CodecComponentTestAdditional, testSendCommand002, Function | MediumTest | Level1)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    int32_t ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_LOADED, cmdData);
    ASSERT_EQ(ret, HDF_SUCCESS);
}
/**
 * @tc.number  SUB_Driver_Codec_SendCommand_0300
 * @tc.name  testSendCommand003
 * @tc.desc  The first and second parameters are CODEC_COMMAND_STATE_SET and CODEC_STATE_IDLE. SendCommand is
 * successful.
 */
HWTEST_F(CodecComponentTestAdditional, testSendCommand003, Function | MediumTest | Level1)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    int32_t ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_IDLE, cmdData);
    ASSERT_EQ(ret, HDF_SUCCESS);
}
/**
 * @tc.number  SUB_Driver_Codec_SendCommand_0400
 * @tc.name  testSendCommand004
 * @tc.desc  The first and second parameters are CODEC_COMMAND_STATE_SET and CODEC_STATE_EXECUTING. SendCommand is
 * successful.
 */
HWTEST_F(CodecComponentTestAdditional, testSendCommand004, Function | MediumTest | Level1)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    int32_t ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_EXECUTING, cmdData);
    ASSERT_EQ(ret, HDF_SUCCESS);
}
/**
 * @tc.number  SUB_Driver_Codec_SendCommand_0500
 * @tc.name  testSendCommand005
 * @tc.desc  The first and second parameters are CODEC_COMMAND_STATE_SET and CODEC_STATE_PAUSE. SendCommand is
 * successful.
 */
HWTEST_F(CodecComponentTestAdditional, testSendCommand005, Function | MediumTest | Level1)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    int32_t ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_PAUSE, cmdData);
    ASSERT_EQ(ret, HDF_SUCCESS);
}
/**
 * @tc.number  SUB_Driver_Codec_SendCommand_0600
 * @tc.name  testSendCommand006
 * @tc.desc  The first and second parameters are CODEC_COMMAND_STATE_SET and CODEC_STATE_WAIT_FOR_RESOURCES. SendCommand
 * is successful.
 */
HWTEST_F(CodecComponentTestAdditional, testSendCommand006, Function | MediumTest | Level1)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    int32_t ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_WAIT_FOR_RESOURCES, cmdData);
    ASSERT_EQ(ret, HDF_SUCCESS);
}
#ifdef SUPPORT_OMX
/**
 * @tc.number  SUB_Driver_Codec_SendCommand_0700
 * @tc.name  testSendCommand007
 * @tc.desc  The first and second parameters are CODEC_COMMAND_STATE_SET and CODEC_STATE_KHRONOS_EXTENSIONS. SendCommand
 * is successful.
 */
HWTEST_F(CodecComponentTestAdditional, testSendCommand007, Function | MediumTest | Level1)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    int32_t ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_KHRONOS_EXTENSIONS, cmdData);
    ASSERT_EQ(ret, HDF_SUCCESS);
}
/**
 * @tc.number  SUB_Driver_Codec_SendCommand_0800
 * @tc.name  testSendCommand008
 * @tc.desc  The first and second parameters are CODEC_COMMAND_STATE_SET and CODEC_STATE_VENDOR_START_UNUSED.
 * SendCommand is successful.
 */
HWTEST_F(CodecComponentTestAdditional, testSendCommand008, Function | MediumTest | Level1)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    int32_t ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_VENDOR_START_UNUSED, cmdData);
    ASSERT_EQ(ret, HDF_SUCCESS);
}
/**
 * @tc.number  SUB_Driver_Codec_SendCommand_0900
 * @tc.name  testSendCommand009
 * @tc.desc  The first and second parameters are CODEC_COMMAND_STATE_SET and CODEC_STATE_MAX. SendCommand is successful.
 */
HWTEST_F(CodecComponentTestAdditional, testSendCommand009, Function | MediumTest | Level1)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    int32_t ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_MAX, cmdData);
    ASSERT_EQ(ret, HDF_SUCCESS);
}
/**
 * @tc.number  SUB_Driver_Codec_SendCommand_1000
 * @tc.name  testSendCommand010
 * @tc.desc  The first and second parameters are CODEC_COMMAND_STATE_SET and -1. SendCommand is successful.
 */
HWTEST_F(CodecComponentTestAdditional, testSendCommand010, Function | MediumTest | Level1)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    int32_t ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, -1, cmdData);
    ASSERT_EQ(ret, HDF_SUCCESS);
}
/**
 * @tc.number  SUB_Driver_Codec_SendCommand_1100
 * @tc.name  testSendCommand011
 * @tc.desc  The first and second parameters are CODEC_COMMAND_FLUSH and -1. SendCommand is error.
 */
HWTEST_F(CodecComponentTestAdditional, testSendCommand011, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    int32_t ret = g_component->SendCommand(CODEC_COMMAND_FLUSH, -1, cmdData);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number  SUB_Driver_Codec_SendCommand_1200
 * @tc.name  testSendCommand012
 * @tc.desc  The first and second parameters are CODEC_COMMAND_FLUSH and 0. SendCommand is error.
 */
HWTEST_F(CodecComponentTestAdditional, testSendCommand012, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    int32_t ret = g_component->SendCommand(CODEC_COMMAND_FLUSH, 0, cmdData);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number  SUB_Driver_Codec_SendCommand_1300
 * @tc.name  testSendCommand013
 * @tc.desc  The first and second parameters are CODEC_COMMAND_FLUSH and 1. SendCommand is error.
 */
HWTEST_F(CodecComponentTestAdditional, testSendCommand013, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    int32_t ret = g_component->SendCommand(CODEC_COMMAND_FLUSH, 1, cmdData);
    ASSERT_NE(ret, HDF_SUCCESS);
}
#endif
/**
 * @tc.number  SUB_Driver_Codec_SendCommand_1400
 * @tc.name  testSendCommand014
 * @tc.desc  The first and second parameters are CODEC_COMMAND_FLUSH and CODEC_STATE_PAUSE. SendCommand is error.
 */
HWTEST_F(CodecComponentTestAdditional, testSendCommand014, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    int32_t ret = g_component->SendCommand(CODEC_COMMAND_FLUSH, CODEC_STATE_PAUSE, cmdData);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number  SUB_Driver_Codec_SendCommand_1500
 * @tc.name  testSendCommand015
 * @tc.desc  The first and second parameters are CODEC_COMMAND_PORT_DISABLE and -1. SendCommand is successful.
 */
HWTEST_F(CodecComponentTestAdditional, testSendCommand015, Function | MediumTest | Level1)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    int32_t ret = g_component->SendCommand(CODEC_COMMAND_PORT_DISABLE, -1, cmdData);
    ASSERT_EQ(ret, HDF_SUCCESS);
}
/**
 * @tc.number  SUB_Driver_Codec_SendCommand_1600
 * @tc.name  testSendCommand016
 * @tc.desc  The first and second parameters are CODEC_COMMAND_PORT_DISABLE and 0. SendCommand is successful.
 */
HWTEST_F(CodecComponentTestAdditional, testSendCommand016, Function | MediumTest | Level1)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    int32_t ret = g_component->SendCommand(CODEC_COMMAND_PORT_DISABLE, 0, cmdData);
    ASSERT_EQ(ret, HDF_SUCCESS);
}
/**
 * @tc.number  SUB_Driver_Codec_SendCommand_1700
 * @tc.name  testSendCommand017
 * @tc.desc  The first and second parameters are CODEC_COMMAND_PORT_DISABLE and 1. SendCommand is successful.
 */
HWTEST_F(CodecComponentTestAdditional, testSendCommand017, Function | MediumTest | Level1)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    int32_t ret = g_component->SendCommand(CODEC_COMMAND_PORT_DISABLE, 1, cmdData);
    ASSERT_EQ(ret, HDF_SUCCESS);
}
#ifdef SUPPORT_OMX
/**
 * @tc.number  SUB_Driver_Codec_SendCommand_1800
 * @tc.name  testSendCommand018
 * @tc.desc  The first and second parameters are CODEC_COMMAND_PORT_DISABLE and CODEC_STATE_PAUSE. SendCommand is error.
 */
HWTEST_F(CodecComponentTestAdditional, testSendCommand018, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    int32_t ret = g_component->SendCommand(CODEC_COMMAND_PORT_DISABLE, CODEC_STATE_PAUSE, cmdData);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number  SUB_Driver_Codec_SendCommand_1900
 * @tc.name  testSendCommand019
 * @tc.desc  The first and second parameters are CODEC_COMMAND_PORT_ENABLE and -1. SendCommand is error.
 */
HWTEST_F(CodecComponentTestAdditional, testSendCommand019, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    int32_t ret = g_component->SendCommand(CODEC_COMMAND_PORT_ENABLE, -1, cmdData);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number  SUB_Driver_Codec_SendCommand_2000
 * @tc.name  testSendCommand020
 * @tc.desc  The first and second parameters are CODEC_COMMAND_PORT_ENABLE and 0. SendCommand is error.
 */
HWTEST_F(CodecComponentTestAdditional, testSendCommand020, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    int32_t ret = g_component->SendCommand(CODEC_COMMAND_PORT_ENABLE, 0, cmdData);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number  SUB_Driver_Codec_SendCommand_2100
 * @tc.name  testSendCommand021
 * @tc.desc  The first and second parameters are CODEC_COMMAND_PORT_ENABLE and 1. SendCommand is error.
 */
HWTEST_F(CodecComponentTestAdditional, testSendCommand021, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    int32_t ret = g_component->SendCommand(CODEC_COMMAND_PORT_ENABLE, 1, cmdData);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number  SUB_Driver_Codec_SendCommand_2200
 * @tc.name  testSendCommand022
 * @tc.desc  The first and second parameters are CODEC_COMMAND_PORT_ENABLE and CODEC_STATE_PAUSE. SendCommand is error.
 */
HWTEST_F(CodecComponentTestAdditional, testSendCommand022, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    int32_t ret = g_component->SendCommand(CODEC_COMMAND_PORT_ENABLE, CODEC_STATE_PAUSE, cmdData);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number  SUB_Driver_Codec_SendCommand_2300
 * @tc.name  testSendCommand023
 * @tc.desc  The first and second parameters are CODEC_COMMAND_MARK_BUFFER and -1. SendCommand is error.
 */
HWTEST_F(CodecComponentTestAdditional, testSendCommand023, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    int32_t ret = g_component->SendCommand(CODEC_COMMAND_MARK_BUFFER, -1, cmdData);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number  SUB_Driver_Codec_SendCommand_2400
 * @tc.name  testSendCommand024
 * @tc.desc  The first and second parameters are CODEC_COMMAND_MARK_BUFFER and 0. SendCommand is error.
 */
HWTEST_F(CodecComponentTestAdditional, testSendCommand024, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    int32_t ret = g_component->SendCommand(CODEC_COMMAND_MARK_BUFFER, 0, cmdData);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number  SUB_Driver_Codec_SendCommand_2500
 * @tc.name  testSendCommand025
 * @tc.desc  The first and second parameters are CODEC_COMMAND_MARK_BUFFER and 1. SendCommand is error.
 */
HWTEST_F(CodecComponentTestAdditional, testSendCommand025, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    int32_t ret = g_component->SendCommand(CODEC_COMMAND_MARK_BUFFER, 1, cmdData);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number  SUB_Driver_Codec_SendCommand_2600
 * @tc.name  testSendCommand026
 * @tc.desc  The first and second parameters are CODEC_COMMAND_MARK_BUFFER and CODEC_STATE_PAUSE. SendCommand is error.
 */
HWTEST_F(CodecComponentTestAdditional, testSendCommand026, Function | MediumTest | Level2)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    int32_t ret = g_component->SendCommand(CODEC_COMMAND_MARK_BUFFER, CODEC_STATE_PAUSE, cmdData);
    ASSERT_NE(ret, HDF_SUCCESS);
}
/**
 * @tc.number  SUB_Driver_Codec_SendCommand_2700
 * @tc.name  testSendCommand027
 * @tc.desc  The first and second parameters are CODEC_COMMAND_KHRONOS_EXTENSIONS and -1. SendCommand is successful.
 */
HWTEST_F(CodecComponentTestAdditional, testSendCommand027, Function | MediumTest | Level1)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    int32_t ret = g_component->SendCommand(CODEC_COMMAND_KHRONOS_EXTENSIONS, -1, cmdData);
    ASSERT_EQ(ret, HDF_SUCCESS);
}
/**
 * @tc.number  SUB_Driver_Codec_SendCommand_2800
 * @tc.name  testSendCommand028
 * @tc.desc  The first and second parameters are CODEC_COMMAND_KHRONOS_EXTENSIONS and 0. SendCommand is successful.
 */
HWTEST_F(CodecComponentTestAdditional, testSendCommand028, Function | MediumTest | Level1)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    int32_t ret = g_component->SendCommand(CODEC_COMMAND_KHRONOS_EXTENSIONS, 0, cmdData);
    ASSERT_EQ(ret, HDF_SUCCESS);
}
/**
 * @tc.number  SUB_Driver_Codec_SendCommand_2900
 * @tc.name  testSendCommand029
 * @tc.desc  The first and second parameters are CODEC_COMMAND_KHRONOS_EXTENSIONS and 1. SendCommand is successful.
 */
HWTEST_F(CodecComponentTestAdditional, testSendCommand029, Function | MediumTest | Level1)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    int32_t ret = g_component->SendCommand(CODEC_COMMAND_KHRONOS_EXTENSIONS, 1, cmdData);
    ASSERT_EQ(ret, HDF_SUCCESS);
}
/**
 * @tc.number  SUB_Driver_Codec_SendCommand_3000
 * @tc.name  testSendCommand030
 * @tc.desc  The first and second parameters are CODEC_COMMAND_KHRONOS_EXTENSIONS and CODEC_STATE_PAUSE. SendCommand is
 * successful.
 */
HWTEST_F(CodecComponentTestAdditional, testSendCommand030, Function | MediumTest | Level1)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    int32_t ret = g_component->SendCommand(CODEC_COMMAND_KHRONOS_EXTENSIONS, CODEC_STATE_PAUSE, cmdData);
    ASSERT_EQ(ret, HDF_SUCCESS);
}
/**
 * @tc.number  SUB_Driver_Codec_SendCommand_3100
 * @tc.name  testSendCommand031
 * @tc.desc  The first and second parameters are CODEC_COMMAND_VENDOR_START_UNUSED and -1. SendCommand is successful.
 */
HWTEST_F(CodecComponentTestAdditional, testSendCommand031, Function | MediumTest | Level1)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    int32_t ret = g_component->SendCommand(CODEC_COMMAND_VENDOR_START_UNUSED, -1, cmdData);
    ASSERT_EQ(ret, HDF_SUCCESS);
}
/**
 * @tc.number  SUB_Driver_Codec_SendCommand_3200
 * @tc.name  testSendCommand032
 * @tc.desc  The first and second parameters are CODEC_COMMAND_VENDOR_START_UNUSED and 0. SendCommand is successful.
 */
HWTEST_F(CodecComponentTestAdditional, testSendCommand032, Function | MediumTest | Level1)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    int32_t ret = g_component->SendCommand(CODEC_COMMAND_VENDOR_START_UNUSED, 0, cmdData);
    ASSERT_EQ(ret, HDF_SUCCESS);
}
/**
 * @tc.number  SUB_Driver_Codec_SendCommand_3300
 * @tc.name  testSendCommand033
 * @tc.desc  The first and second parameters are CODEC_COMMAND_VENDOR_START_UNUSED and 1. SendCommand is successful.
 */
HWTEST_F(CodecComponentTestAdditional, testSendCommand033, Function | MediumTest | Level1)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    int32_t ret = g_component->SendCommand(CODEC_COMMAND_VENDOR_START_UNUSED, 1, cmdData);
    ASSERT_EQ(ret, HDF_SUCCESS);
}
/**
 * @tc.number  SUB_Driver_Codec_SendCommand_3400
 * @tc.name  testSendCommand034
 * @tc.desc  The first and second parameters are CODEC_COMMAND_VENDOR_START_UNUSED and CODEC_STATE_PAUSE. SendCommand is
 * successful.
 */
HWTEST_F(CodecComponentTestAdditional, testSendCommand034, Function | MediumTest | Level1)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    int32_t ret = g_component->SendCommand(CODEC_COMMAND_VENDOR_START_UNUSED, CODEC_STATE_PAUSE, cmdData);
    ASSERT_EQ(ret, HDF_SUCCESS);
}
/**
 * @tc.number  SUB_Driver_Codec_SendCommand_3500
 * @tc.name  testSendCommand035
 * @tc.desc  The first and second parameters are CODEC_COMMAND_MAX and -1. SendCommand is successful.
 */
HWTEST_F(CodecComponentTestAdditional, testSendCommand035, Function | MediumTest | Level1)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    int32_t ret = g_component->SendCommand(CODEC_COMMAND_MAX, -1, cmdData);
    ASSERT_EQ(ret, HDF_SUCCESS);
}
/**
 * @tc.number  SUB_Driver_Codec_SendCommand_3600
 * @tc.name  testSendCommand036
 * @tc.desc  The first and second parameters are CODEC_COMMAND_MAX and 0. SendCommand is successful.
 */
HWTEST_F(CodecComponentTestAdditional, testSendCommand036, Function | MediumTest | Level1)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    int32_t ret = g_component->SendCommand(CODEC_COMMAND_MAX, 0, cmdData);
    ASSERT_EQ(ret, HDF_SUCCESS);
}
/**
 * @tc.number  SUB_Driver_Codec_SendCommand_3700
 * @tc.name  testSendCommand037
 * @tc.desc  The first and second parameters are CODEC_COMMAND_MAX and 1. SendCommand is successful.
 */
HWTEST_F(CodecComponentTestAdditional, testSendCommand037, Function | MediumTest | Level1)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    int32_t ret = g_component->SendCommand(CODEC_COMMAND_MAX, 1, cmdData);
    ASSERT_EQ(ret, HDF_SUCCESS);
}
/**
 * @tc.number  SUB_Driver_Codec_SendCommand_3800
 * @tc.name  testSendCommand038
 * @tc.desc  The first and second parameters are CODEC_COMMAND_MAX and CODEC_STATE_PAUSE. SendCommand is successful.
 */
HWTEST_F(CodecComponentTestAdditional, testSendCommand038, Function | MediumTest | Level1)
{
    ASSERT_TRUE(g_component != nullptr);
    std::vector<int8_t> cmdData;
    int32_t ret = g_component->SendCommand(CODEC_COMMAND_MAX, CODEC_STATE_PAUSE, cmdData);
    ASSERT_EQ(ret, HDF_SUCCESS);
}
#endif
} // namespace