/* * 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 #include #include #include #include #include #include #include #include #include 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 g_component = nullptr; static sptr g_callback = nullptr; static sptr 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(PortIndex::PORT_INDEX_INPUT); const static uint32_t OUTPUT_INDEX = static_cast(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 void InitParam(T ¶m) { memset_s(¶m, sizeof(param), 0x0, sizeof(param)); param.size = sizeof(param); param.version.nVersion = 1; } template void ObjectToVector(T ¶m, std::vector &vec) { int8_t *paramPointer = reinterpret_cast(¶m); 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 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(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 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 inParam; ObjectToVector(param, inParam); std::vector 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 inParam; ObjectToVector(param, inParam); std::vector 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 inParam; ObjectToVector(param, inParam); std::vector 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 inParam; ObjectToVector(param, inParam); std::vector 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 inParam; ObjectToVector(param, inParam); std::vector 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 inParam; ObjectToVector(param, inParam); std::vector 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 inParam; std::vector 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 inParam; ObjectToVector(param, inParam); std::vector 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 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 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 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 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 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 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 inParam; ObjectToVector(param, inParam); std::vector 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 inParam; ObjectToVector(param, inParam); std::vector 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 inParam; ObjectToVector(param, inParam); std::vector 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 inParam; ObjectToVector(param, inParam); std::vector 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 inParam; ObjectToVector(param, inParam); std::vector 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 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 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 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 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 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 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 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 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 "OMX.Topaz.index.param.extended_video" 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( "OMX.Topaz.index.param.extended_video", 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 "12345" 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("12345", indexType); ASSERT_NE(ret, HDF_SUCCESS); } /** * @tc.number : SUB_Driver_Codec_GetExtensionIndex_1100 * @tc.name : testGetExtensionIndex010 * @tc.desc : When the paramName is "12345OMX.Topaz" 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("12345OMX.Topaz", indexType); ASSERT_NE(ret, HDF_SUCCESS); } /** * @tc.number : SUB_Driver_Codec_GetExtensionIndex_1200 * @tc.name : testGetExtensionIndex011 * @tc.desc : When the paramName is "12345!@#$%" 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("12345O!@#$%", indexType); ASSERT_NE(ret, HDF_SUCCESS); } /** * @tc.number : SUB_Driver_Codec_GetExtensionIndex_1300 * @tc.name : testGetExtensionIndex012 * @tc.desc : When the paramName is "12345!@#$" 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("12345!@#$", indexType); ASSERT_NE(ret, HDF_SUCCESS); } /** * @tc.number : SUB_Driver_Codec_GetExtensionIndex_1400 * @tc.name : testGetExtensionIndex013 * @tc.desc : When the paramName is "12345OMX.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("12345OMX.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 "!@#$%OMX.Topaz" 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("!@#$%OMX.Topaz", indexType); ASSERT_NE(ret, HDF_SUCCESS); } /** * @tc.number : SUB_Driver_Codec_GetExtensionIndex_1700 * @tc.name : testGetExtensionIndex016 * @tc.desc : When the paramName is "12345OMX.Topaz" 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("12345OMX.Topaz", 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 cmdData; auto ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_IDLE, cmdData); ASSERT_EQ(ret, HDF_SUCCESS); std::shared_ptr omxBuffer = std::make_shared(); 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 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 omxBuffer = std::make_shared(); 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 cmdData; auto ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_INVALID, cmdData); ASSERT_EQ(ret, HDF_SUCCESS); std::shared_ptr omxBuffer = std::make_shared(); 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 cmdData; auto ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_LOADED, cmdData); ASSERT_EQ(ret, HDF_SUCCESS); std::shared_ptr omxBuffer = std::make_shared(); 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 cmdData; auto ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_EXECUTING, cmdData); ASSERT_EQ(ret, HDF_SUCCESS); std::shared_ptr omxBuffer = std::make_shared(); 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 cmdData; auto ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_PAUSE, cmdData); ASSERT_EQ(ret, HDF_SUCCESS); std::shared_ptr omxBuffer = std::make_shared(); 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 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 omxBuffer = std::make_shared(); 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 cmdData; auto ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_WAIT_FOR_RESOURCES, cmdData); ASSERT_EQ(ret, HDF_SUCCESS); std::shared_ptr omxBuffer = std::make_shared(); 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 cmdData; auto ret = g_component->SendCommand(CODEC_COMMAND_STATE_SET, CODEC_STATE_IDLE, cmdData); ASSERT_EQ(ret, HDF_SUCCESS); std::shared_ptr omxBuffer = std::make_shared(); 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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(BUFFER_SIZE); ASSERT_TRUE(eglImage != nullptr); std::vector 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(BUFFER_SIZE); ASSERT_TRUE(eglImage != nullptr); std::vector 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(BUFFER_SIZE); ASSERT_TRUE(eglImage != nullptr); std::vector 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 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(BUFFER_SIZE); ASSERT_TRUE(eglImage != nullptr); std::vector 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 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(BUFFER_SIZE); ASSERT_TRUE(eglImage != nullptr); std::vector 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 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(BUFFER_SIZE); ASSERT_TRUE(eglImage != nullptr); std::vector 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 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(BUFFER_SIZE); ASSERT_TRUE(eglImage != nullptr); std::vector 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 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(BUFFER_SIZE); ASSERT_TRUE(eglImage != nullptr); std::vector 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 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(BUFFER_SIZE); ASSERT_TRUE(eglImage != nullptr); std::vector 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(BUFFER_SIZE); ASSERT_TRUE(eglImage != nullptr); std::vector 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(BUFFER_SIZE); ASSERT_TRUE(eglImage != nullptr); std::vector 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(BUFFER_SIZE); ASSERT_TRUE(eglImage != nullptr); std::vector 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 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(BUFFER_SIZE); ASSERT_TRUE(eglImage != nullptr); std::vector 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 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(BUFFER_SIZE); ASSERT_TRUE(eglImage != nullptr); std::vector 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 cmdData; int32_t ret = g_component->SendCommand(CODEC_COMMAND_MAX, CODEC_STATE_PAUSE, cmdData); ASSERT_EQ(ret, HDF_SUCCESS); } #endif } // namespace