diff --git a/distributed_camera/bundle.json b/distributed_camera/bundle.json index d5e0b5718ef33bd078741718ad952dd6f82fa35c..d1cd7cff4f95364b04031950bc73d44e5a714440 100644 --- a/distributed_camera/bundle.json +++ b/distributed_camera/bundle.json @@ -39,7 +39,7 @@ ], "test":[ - + "//drivers/peripheral/distributed_camera/hdi_service/test/unittest:hdf_service_test" ] } } diff --git a/distributed_camera/hdi_service/src/dstream_operator/dstream_operator.cpp b/distributed_camera/hdi_service/src/dstream_operator/dstream_operator.cpp index f57abcc2cf26535606ff845f4fae56d8187127ad..68dd15cf48423a4567539f8c8e36028297a244b9 100644 --- a/distributed_camera/hdi_service/src/dstream_operator/dstream_operator.cpp +++ b/distributed_camera/hdi_service/src/dstream_operator/dstream_operator.cpp @@ -167,7 +167,6 @@ int32_t DStreamOperator::CommitStreams(OperationMode mode, const std::vector dCameraStreams; int32_t ret = ExtractStreamInfo(dCameraStreams); if (ret != CamRetCode::NO_ERROR) { @@ -973,7 +972,8 @@ void DStreamOperator::EraseDCStream(int32_t streamId) dcStreamInfoMap_.erase(streamId); } -void DStreamOperator::ExtractNotCaptureStream(bool isStreaming, std::vector>& appendStreamInfo) +void DStreamOperator::ExtractNotCaptureStream(bool isStreaming, + std::vector>& appendStreamInfo) { std::lock_guard autoLock(streamAttrLock_); for (auto iter = dcStreamInfoMap_.begin(); iter != dcStreamInfoMap_.end(); iter++) { diff --git a/distributed_camera/hdi_service/test/unittest/BUILD.gn b/distributed_camera/hdi_service/test/unittest/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..3bc76761ecaee1e4bceb553c12b7548961a5ee7d --- /dev/null +++ b/distributed_camera/hdi_service/test/unittest/BUILD.gn @@ -0,0 +1,20 @@ +# Copyright (c) 2022 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. + +group("hdf_service_test") { + testonly = true + deps = [ + "common/dcamera_device:hdf_dcamera_device_test", + "common/dstream_operator:hdf_dstream_operator_test", + ] +} diff --git a/distributed_camera/hdi_service/test/unittest/common/dcamera_device/BUILD.gn b/distributed_camera/hdi_service/test/unittest/common/dcamera_device/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..cc924e720074f80b57cc1683ff40fd61c0b873c8 --- /dev/null +++ b/distributed_camera/hdi_service/test/unittest/common/dcamera_device/BUILD.gn @@ -0,0 +1,91 @@ +# Copyright (c) 2022 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. + +import("//build/ohos.gni") +import("//build/test.gni") +import("//drivers/hdf_core/adapter/uhdf2/uhdf.gni") +import("//drivers/peripheral/distributed_camera/distributedcamera.gni") + +module_out_path = + "drivers_peripheral_distributed_camera/hdf_dcamera_device_test" + +config("module_private_config") { + visibility = [ ":*" ] + include_dirs = [ + "${distributedcamera_hdf_path}/hdi_service/include/dcamera_device", + "${distributedcamera_hdf_path}/hdi_service/include/dcamera_host", + "${distributedcamera_hdf_path}/hdi_service/include/dcamera_provider", + "${distributedcamera_hdf_path}/hdi_service/include/dstream_operator", + "${distributedcamera_hdf_path}/hdi_service/include/utils", + "${distributedcamera_hdf_path}/interfaces/hdi_ipc", + "${distributedcamera_hdf_path}/interfaces/hdi_ipc/server/device", + "${distributedcamera_hdf_path}/interfaces/hdi_ipc/server/host", + "${distributedcamera_hdf_path}/interfaces/hdi_ipc/server/operator", + "//utils/native/base/include", + "//utils/system/safwk/native/include", + "${display_hdf_path}/interfaces/include", + "${hdf_framework_path}/include/utils", + "${hdf_framework_path}/include/core", + "${hdf_framework_path}/include/osal", + "${hdf_uhdf_path}/include/hdi", + "${hdf_uhdf_path}/osal/include", + "${hdf_uhdf_path}/ipc/include", + "${hdf_uhdf_path}/include/host", + "//third_party/jsoncpp/include", + "//drivers/peripheral/camera/interfaces/metadata/include", + "${camera_hdf_path}/camera/interfaces/include", + "${camera_hdf_path}/camera/interfaces/hdi_ipc", + ] +} + +ohos_unittest("HdfDcameraDeviceTest") { + module_out_path = module_out_path + + sources = [ "dcamera_device_test.cpp" ] + + configs = [ ":module_private_config" ] + + deps = [ + "${distributedcamera_hdf_path}/hdi_service:libdistributed_camera_hdf_service_1.0", + "//drivers/hdf_core/adapter/uhdf2/ipc:libhdf_ipc_adapter", + "//drivers/peripheral/camera/interfaces/metadata:metadata", + "//third_party/jsoncpp:jsoncpp", + "//utils/native/base:utils", + ] + + public_deps = [ "//drivers/interface/distributed_camera/v1_0:libdistributed_camera_provider_stub_1.0" ] + + external_deps = [ + "drivers_interface_camera:libcamera_proxy_1.0", + "graphic_chipsetsdk:buffer_handle", + "graphic_chipsetsdk:surface", + "hdf_core:libhdf_utils", + "ipc:ipc_single", + "utils_base:utils", + ] + + defines = [ + "HI_LOG_ENABLE", + "DH_LOG_TAG=\"HdfDcameraDeviceTest\"", + "LOG_DOMAIN=0xD004100", + ] + + install_images = [ chipset_base_dir ] + subsystem_name = "hdf" + part_name = "drivers_peripheral_distributed_camera" +} + +group("hdf_dcamera_device_test") { + testonly = true + deps = [ ":HdfDcameraDeviceTest" ] +} diff --git a/distributed_camera/hdi_service/test/unittest/common/dcamera_device/dcamera_device_test.cpp b/distributed_camera/hdi_service/test/unittest/common/dcamera_device/dcamera_device_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..cdff077918ec62071dbe7de011875b8a7c3e12ef --- /dev/null +++ b/distributed_camera/hdi_service/test/unittest/common/dcamera_device/dcamera_device_test.cpp @@ -0,0 +1,131 @@ +/* + * Copyright (c) 2022 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 + +#include "dcamera_device.h" + +using namespace testing::ext; + +namespace OHOS { +namespace DistributedHardware { +class DCameraDeviceTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(void); + void TearDown(void); + + sptr dcameraDevice_ = nullptr; +}; + +constexpr const char* TEST_DEVICE_ID = "bb536a637105409e904d4da83790a4a7"; +constexpr const char* TEST_CAMERA_DH_ID_0 = "camera_0"; +constexpr const char* TEST_ABILITY = R"({"CodecType": ["avenc_mpeg4"], + "OutputFormat": {"Photo":[4], "Preview":[2, 3], "Video":[2, 3]}, + "Position": "BACK", + "ProtocolVer": "1.0", + "MetaData": "", + "Resolution": { + "2": ["1920*1080", "1504*720", "1440*1080", "1280*960", "1280*720", "1232*768", "1152*720", "960*720", "960*544", + "880*720", "720*720", "720*480", "640*480", "352*288", "320*240"], + "3": ["1920*1080", "1504*720", "1440*1080", "1280*960", "1280*720", "1232*768", "1152*720", "960*720", "960*544", + "880*720", "720*720", "720*480", "640*480", "352*288", "320*240"], + "4": ["3840*2160", "3264*2448", "3264*1840", "2304*1728", "2048*1536", "1920*1440", "1920*1080", "1744*1088", + "1280*720", "1232*768", "1152*720", "640*480", "320*240"]}})"; + +void DCameraDeviceTest::SetUpTestCase(void) +{ +} + +void DCameraDeviceTest::TearDownTestCase(void) +{ +} + +void DCameraDeviceTest::SetUp(void) +{ + DHBase dhBase = {TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0}; + dcameraDevice_ = new (std::nothrow) DCameraDevice(dhBase, TEST_ABILITY); +} + +void DCameraDeviceTest::TearDown(void) +{ +} + +/** + * @tc.name: dcamera_device_test_001 + * @tc.desc: Verify SetResultMode + * @tc.type: FUNC + * @tc.require: AR + */ +HWTEST_F(DCameraDeviceTest, dcamera_device_test_001, TestSize.Level0) +{ + EXPECT_EQ(false, dcameraDevice_ == nullptr); + + ResultCallbackMode mode = PER_FRAME; + int32_t rc = dcameraDevice_->SetResultMode(mode); + EXPECT_EQ(true, rc == CamRetCode::NO_ERROR); +} + +/** + * @tc.name: dcamera_device_test_002 + * @tc.desc: Verify GetEnabledResults + * @tc.type: FUNC + * @tc.require: AR + */ +HWTEST_F(DCameraDeviceTest, dcamera_device_test_002, TestSize.Level1) +{ + EXPECT_EQ(false, dcameraDevice_ == nullptr); + + std::vector results; + int32_t rc = dcameraDevice_->GetEnabledResults(results); + EXPECT_EQ(true, rc == CamRetCode::NO_ERROR); +} + +/** + * @tc.name: dcamera_device_test_003 + * @tc.desc: Verify SetResultMode ON_CHANGED + * @tc.type: FUNC + * @tc.require: AR + */ +HWTEST_F(DCameraDeviceTest, dcamera_device_test_003, TestSize.Level1) +{ + EXPECT_EQ(false, dcameraDevice_ == nullptr); + + ResultCallbackMode mode = ON_CHANGED; + int32_t rc = dcameraDevice_->SetResultMode(mode); + EXPECT_EQ(true, rc == CamRetCode::NO_ERROR); + + std::vector results; + rc = dcameraDevice_->GetEnabledResults(results); + EXPECT_EQ(true, rc == CamRetCode::NO_ERROR); +} + +/** + * @tc.name: dcamera_device_test_004 + * @tc.desc: Verify GetDCameraAbility + * @tc.type: FUNC + * @tc.require: AR + */ +HWTEST_F(DCameraDeviceTest, dcamera_device_test_004, TestSize.Level1) +{ + EXPECT_EQ(false, dcameraDevice_ == nullptr); + + std::shared_ptr ability = nullptr; + CamRetCode rc = dcameraDevice_->GetDCameraAbility(ability); + EXPECT_EQ(true, rc == CamRetCode::NO_ERROR); +} +} +} \ No newline at end of file diff --git a/distributed_camera/hdi_service/test/unittest/common/dstream_operator/BUILD.gn b/distributed_camera/hdi_service/test/unittest/common/dstream_operator/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..d203226c0fe70ee67eb33dbafec7e72b8f99ec5d --- /dev/null +++ b/distributed_camera/hdi_service/test/unittest/common/dstream_operator/BUILD.gn @@ -0,0 +1,92 @@ +# Copyright (c) 2022 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. + +import("//build/ohos.gni") +import("//build/test.gni") +import("//drivers/hdf_core/adapter/uhdf2/uhdf.gni") +import("//drivers/peripheral/distributed_camera/distributedcamera.gni") + +module_out_path = + "drivers_peripheral_distributed_camera/hdf_dstream_operator_test" + +config("module_private_config") { + visibility = [ ":*" ] + include_dirs = [ + "include", + "${distributedcamera_hdf_path}/hdi_service/include/dcamera_device", + "${distributedcamera_hdf_path}/hdi_service/include/dcamera_host", + "${distributedcamera_hdf_path}/hdi_service/include/dcamera_provider", + "${distributedcamera_hdf_path}/hdi_service/include/dstream_operator", + "${distributedcamera_hdf_path}/hdi_service/include/utils", + "${distributedcamera_hdf_path}/interfaces/hdi_ipc", + "${distributedcamera_hdf_path}/interfaces/hdi_ipc/server/device", + "${distributedcamera_hdf_path}/interfaces/hdi_ipc/server/host", + "${distributedcamera_hdf_path}/interfaces/hdi_ipc/server/operator", + "//utils/native/base/include", + "//utils/system/safwk/native/include", + "${display_hdf_path}/interfaces/include", + "${hdf_framework_path}/include/utils", + "${hdf_framework_path}/include/core", + "${hdf_framework_path}/include/osal", + "${hdf_uhdf_path}/include/hdi", + "${hdf_uhdf_path}/osal/include", + "${hdf_uhdf_path}/ipc/include", + "${hdf_uhdf_path}/include/host", + "//third_party/jsoncpp/include", + "//drivers/peripheral/camera/interfaces/metadata/include", + "${camera_hdf_path}/camera/interfaces/include", + "${camera_hdf_path}/camera/interfaces/hdi_ipc", + ] +} + +ohos_unittest("HdfDstreamOperatorTest") { + module_out_path = module_out_path + + sources = [ "dstream_operator_test.cpp" ] + + configs = [ ":module_private_config" ] + + deps = [ + "${distributedcamera_hdf_path}/hdi_service:libdistributed_camera_hdf_service_1.0", + "//drivers/hdf_core/adapter/uhdf2/ipc:libhdf_ipc_adapter", + "//drivers/peripheral/camera/interfaces/metadata:metadata", + "//third_party/jsoncpp:jsoncpp", + "//utils/native/base:utils", + ] + + public_deps = [ "//drivers/interface/distributed_camera/v1_0:libdistributed_camera_provider_stub_1.0" ] + + external_deps = [ + "drivers_interface_camera:libcamera_proxy_1.0", + "graphic_chipsetsdk:buffer_handle", + "graphic_chipsetsdk:surface", + "hdf_core:libhdf_utils", + "ipc:ipc_single", + "utils_base:utils", + ] + + defines = [ + "HI_LOG_ENABLE", + "DH_LOG_TAG=\"HdfDstreamOperatorTest\"", + "LOG_DOMAIN=0xD004100", + ] + + install_images = [ chipset_base_dir ] + subsystem_name = "hdf" + part_name = "drivers_peripheral_distributed_camera" +} + +group("hdf_dstream_operator_test") { + testonly = true + deps = [ ":HdfDstreamOperatorTest" ] +} diff --git a/distributed_camera/hdi_service/test/unittest/common/dstream_operator/dstream_operator_test.cpp b/distributed_camera/hdi_service/test/unittest/common/dstream_operator/dstream_operator_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..037393a0de3f5529cc1a5032727d6f987cc31c0a --- /dev/null +++ b/distributed_camera/hdi_service/test/unittest/common/dstream_operator/dstream_operator_test.cpp @@ -0,0 +1,326 @@ +/* + * Copyright (c) 2022 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 + +#include "dstream_operator.h" +#include "distributed_hardware_log.h" +#include "mock_dstream_operator_callback.h" +#include "metadata_utils.h" + +using namespace testing::ext; + +namespace OHOS { +namespace DistributedHardware { +class DStreamOperatorTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(void); + void TearDown(void); + + OHOS::sptr dstreamOperator_ = nullptr; +}; + +constexpr const char* TEST_DEV_ID = "bb536a637105409e904d4da83790a4a7"; +constexpr const char* TEST_CAM_ID = "camera_0"; +constexpr const char* TEST_ABILITY_VALUE = R"({"CodecType": ["avenc_mpeg4"], + "OutputFormat": {"Photo":[4], "Preview":[2, 3], "Video":[2, 3]}, + "Position": "BACK", + "ProtocolVer": "1.0", + "MetaData": "", + "Resolution": { + "2": ["1920*1080", "1504*720", "1440*1080", "1280*960", "1280*720", "1232*768", "1152*720", "960*720", "960*544", + "880*720", "720*720", "720*480", "640*480", "352*288", "320*240"], + "3": ["1920*1080", "1504*720", "1440*1080", "1280*960", "1280*720", "1232*768", "1152*720", "960*720", "960*544", + "880*720", "720*720", "720*480", "640*480", "352*288", "320*240"], + "4": ["3840*2160", "3264*2448", "3264*1840", "2304*1728", "2048*1536", "1920*1440", "1920*1080", "1744*1088", + "1280*720", "1232*768", "1152*720", "640*480", "320*240"]}})"; +constexpr int TEST_STREAMID = 1001; +constexpr int TEST_HEIGHT = 480; +constexpr int TEST_WIDTH = 640; +constexpr int TEST_DATASPACE = 8; +constexpr int TEST_TUNNELEDMODE = 5; + +void DStreamOperatorTest::SetUpTestCase(void) +{ +} + +void DStreamOperatorTest::TearDownTestCase(void) +{ +} + +void DStreamOperatorTest::SetUp(void) +{ + std::shared_ptr dMetadataProcessor = std::make_shared(); + dMetadataProcessor->InitDCameraAbility(TEST_ABILITY_VALUE); + dstreamOperator_ = new (std::nothrow) DStreamOperator(dMetadataProcessor); +} + +void DStreamOperatorTest::TearDown(void) +{ +} + +/** + * @tc.name: dstream_operator_test_001 + * @tc.desc: Verify InitOutputConfigurations + * @tc.type: FUNC + * @tc.require: AR + */ +HWTEST_F(DStreamOperatorTest, dstream_operator_test_001, TestSize.Level1) +{ + EXPECT_EQ(false, dstreamOperator_ == nullptr); + + DHBase dhBase; + dhBase.deviceId_ = TEST_DEV_ID; + dhBase.dhId_ = TEST_CAM_ID; + DCamRetCode rc = dstreamOperator_->InitOutputConfigurations(dhBase, TEST_ABILITY_VALUE); + EXPECT_EQ(rc, SUCCESS); +} + +/** + * @tc.name: dstream_operator_test_002 + * @tc.desc: Verify IsStreamsSupported + * @tc.type: FUNC + * @tc.require: AR + */ +HWTEST_F(DStreamOperatorTest, dstream_operator_test_002, TestSize.Level1) +{ + EXPECT_EQ(false, dstreamOperator_ == nullptr); + + OperationMode mode = NORMAL; + std::vector modeSetting; + // Configure stream information + struct StreamInfo streamInfo; + streamInfo.streamId_ = TEST_STREAMID; + streamInfo.format_ = PIXEL_FMT_YCRCB_420_SP; + streamInfo.height_ = TEST_HEIGHT; + streamInfo.width_ = TEST_WIDTH; + streamInfo.dataspace_ = TEST_DATASPACE; + streamInfo.intent_ = StreamIntent::PREVIEW; + streamInfo.tunneledMode_ = TEST_TUNNELEDMODE; + streamInfo.bufferQueue_ = new BufferProducerSequenceable(); + streamInfo.encodeType_ = EncodeType::ENCODE_TYPE_H264; + StreamSupportType pType; + std::vector stre; + stre.push_back(streamInfo); + int32_t rc = dstreamOperator_->IsStreamsSupported(mode, modeSetting, stre, pType); + EXPECT_EQ(rc, CamRetCode::NO_ERROR); + EXPECT_EQ(pType, DYNAMIC_SUPPORTED); +} + +/** + * @tc.name: dstream_operator_test_003 + * @tc.desc: Verify CreateStreams + * @tc.type: FUNC + * @tc.require: AR + */ +HWTEST_F(DStreamOperatorTest, dstream_operator_test_003, TestSize.Level1) +{ + EXPECT_EQ(false, dstreamOperator_ == nullptr); + + struct StreamInfo streamInfo; + streamInfo.streamId_ = TEST_STREAMID; + streamInfo.width_ = TEST_WIDTH; + streamInfo.height_ = TEST_HEIGHT; + streamInfo.format_ = PIXEL_FMT_YCRCB_420_SP; + streamInfo.dataspace_ = TEST_DATASPACE; + streamInfo.intent_ = StreamIntent::PREVIEW; + streamInfo.tunneledMode_ = TEST_TUNNELEDMODE; + streamInfo.bufferQueue_ = new BufferProducerSequenceable(); + streamInfo.encodeType_ = EncodeType::ENCODE_TYPE_NULL; + std::vector streamInfos; + streamInfos.push_back(streamInfo); + int32_t rc = dstreamOperator_->CreateStreams(streamInfos); + EXPECT_EQ(rc, CamRetCode::NO_ERROR); +} + +/** + * @tc.name: dstream_operator_test_004 + * @tc.desc: Verify ReleaseStreams + * @tc.type: FUNC + * @tc.require: AR + */ +HWTEST_F(DStreamOperatorTest, dstream_operator_test_004, TestSize.Level1) +{ + EXPECT_EQ(false, dstreamOperator_ == nullptr); + + struct StreamInfo streamInfo; + streamInfo.streamId_ = TEST_STREAMID; + streamInfo.width_ = TEST_WIDTH; + streamInfo.height_ = TEST_HEIGHT; + streamInfo.format_ = PIXEL_FMT_YCRCB_420_SP; + streamInfo.dataspace_ = TEST_DATASPACE; + streamInfo.intent_ = StreamIntent::PREVIEW; + streamInfo.tunneledMode_ = TEST_TUNNELEDMODE; + streamInfo.bufferQueue_ = new BufferProducerSequenceable(); + streamInfo.encodeType_ = EncodeType::ENCODE_TYPE_NULL; + std::vector streamInfos; + streamInfos.push_back(streamInfo); + int32_t rc = dstreamOperator_->CreateStreams(streamInfos); + EXPECT_EQ(rc, CamRetCode::NO_ERROR); + // release stream + std::vector streamIds; + streamIds.push_back(streamInfo.streamId_); + rc = dstreamOperator_->ReleaseStreams(streamIds); + EXPECT_NE(rc, CamRetCode::NO_ERROR); +} + +/** + * @tc.name: dstream_operator_test_005 + * @tc.desc: Verify GetStreamAttributes + * @tc.type: FUNC + * @tc.require: AR + */ +HWTEST_F(DStreamOperatorTest, dstream_operator_test_005, TestSize.Level1) +{ + EXPECT_EQ(false, dstreamOperator_ == nullptr); + + struct StreamInfo streamInfo; + streamInfo.streamId_ = TEST_STREAMID; + streamInfo.width_ = TEST_WIDTH; + streamInfo.height_ = TEST_HEIGHT; + streamInfo.format_ = PIXEL_FMT_YCRCB_420_SP; + streamInfo.dataspace_ = TEST_DATASPACE; + streamInfo.intent_ = StreamIntent::PREVIEW; + streamInfo.tunneledMode_ = TEST_TUNNELEDMODE; + streamInfo.bufferQueue_ = new BufferProducerSequenceable(); + std::vector streamInfos; + streamInfos.push_back(streamInfo); + int32_t rc = dstreamOperator_->CreateStreams(streamInfos); + EXPECT_EQ(rc, CamRetCode::NO_ERROR); + + std::vector attributes; + rc = dstreamOperator_->GetStreamAttributes(attributes); + EXPECT_EQ(rc, CamRetCode::NO_ERROR); + // release stream + std::vector streamIds; + streamIds.push_back(streamInfo.streamId_); + rc = dstreamOperator_->ReleaseStreams(streamIds); + EXPECT_NE(rc, CamRetCode::NO_ERROR); +} + +/** + * @tc.name: dstream_operator_test_006 + * @tc.desc: Verify AttachBufferQueue + * @tc.type: FUNC + * @tc.require: AR + */ +HWTEST_F(DStreamOperatorTest, dstream_operator_test_006, TestSize.Level1) +{ + EXPECT_EQ(false, dstreamOperator_ == nullptr); + + struct StreamInfo streamInfo; + streamInfo.streamId_ = TEST_STREAMID; + streamInfo.width_ = TEST_WIDTH; + streamInfo.height_ = TEST_HEIGHT; + streamInfo.format_ = PIXEL_FMT_YCRCB_420_SP; + streamInfo.dataspace_ = TEST_DATASPACE; + streamInfo.intent_ = StreamIntent::PREVIEW; + streamInfo.tunneledMode_ = TEST_TUNNELEDMODE; + streamInfo.bufferQueue_ = new BufferProducerSequenceable(); + std::vector streamInfos; + streamInfos.push_back(streamInfo); + int32_t rc = dstreamOperator_->CreateStreams(streamInfos); + EXPECT_EQ(rc, CamRetCode::NO_ERROR); + + sptr bufferProducer; + rc = dstreamOperator_->AttachBufferQueue(streamInfo.streamId_, bufferProducer); + EXPECT_EQ(rc, CamRetCode::NO_ERROR); + // release stream + std::vector streamIds; + streamIds.push_back(streamInfo.streamId_); + rc = dstreamOperator_->ReleaseStreams(streamIds); + EXPECT_NE(rc, CamRetCode::NO_ERROR); +} + +/** + * @tc.name: dstream_operator_test_007 + * @tc.desc: Verify DetachBufferQueue + * @tc.type: FUNC + * @tc.require: AR + */ +HWTEST_F(DStreamOperatorTest, dstream_operator_test_007, TestSize.Level1) +{ + EXPECT_EQ(false, dstreamOperator_ == nullptr); + + struct StreamInfo streamInfo; + streamInfo.streamId_ = TEST_STREAMID; + streamInfo.width_ = TEST_WIDTH; + streamInfo.height_ = TEST_HEIGHT; + streamInfo.format_ = PIXEL_FMT_YCRCB_420_SP; + streamInfo.dataspace_ = TEST_DATASPACE; + streamInfo.intent_ = StreamIntent::PREVIEW; + streamInfo.tunneledMode_ = TEST_TUNNELEDMODE; + streamInfo.bufferQueue_ = new BufferProducerSequenceable(); + std::vector streamInfos; + streamInfos.push_back(streamInfo); + int32_t rc = dstreamOperator_->CreateStreams(streamInfos); + EXPECT_EQ(rc, CamRetCode::NO_ERROR); + + sptr bufferProducer; + rc = dstreamOperator_->AttachBufferQueue(streamInfo.streamId_, bufferProducer); + EXPECT_EQ(rc, CamRetCode::NO_ERROR); + + sleep(3); + rc = dstreamOperator_->DetachBufferQueue(streamInfo.streamId_); + EXPECT_EQ(rc, CamRetCode::NO_ERROR); + // release stream + std::vector streamIds; + streamIds.push_back(streamInfo.streamId_); + rc = dstreamOperator_->ReleaseStreams(streamIds); + EXPECT_NE(rc, CamRetCode::NO_ERROR); +} + +/** + * @tc.name: dstream_operator_test_008 + * @tc.desc: Verify ChangeToOfflineStream + * @tc.type: FUNC + * @tc.require: AR + */ +HWTEST_F(DStreamOperatorTest, dstream_operator_test_008, TestSize.Level1) +{ + EXPECT_EQ(false, dstreamOperator_ == nullptr); + + struct StreamInfo streamInfo; + streamInfo.streamId_ = TEST_STREAMID; + streamInfo.width_ = TEST_WIDTH; + streamInfo.height_ = TEST_HEIGHT; + streamInfo.format_ = PIXEL_FMT_YCRCB_420_SP; + streamInfo.dataspace_ = TEST_DATASPACE; + streamInfo.intent_ = StreamIntent::PREVIEW; + streamInfo.tunneledMode_ = TEST_TUNNELEDMODE; + streamInfo.bufferQueue_ = new BufferProducerSequenceable(); + std::vector streamInfos; + streamInfos.push_back(streamInfo); + int32_t rc = dstreamOperator_->CreateStreams(streamInfos); + EXPECT_EQ(rc, CamRetCode::NO_ERROR); + + int32_t captureId = 1000; + OHOS::sptr offlineStreamOperatorCallback = new (std::nothrow) MockDStreamOperatorCallback(); + std::vector offlineIds; + offlineIds.push_back(captureId); + OHOS::sptr offlineStreamOperator = nullptr; + rc = dstreamOperator_->ChangeToOfflineStream(offlineIds, offlineStreamOperatorCallback, offlineStreamOperator); + EXPECT_EQ(true, offlineStreamOperator == nullptr); + + // release stream + std::vector streamIds; + streamIds.push_back(streamInfo.streamId_); + rc = dstreamOperator_->ReleaseStreams(streamIds); + EXPECT_NE(rc, CamRetCode::NO_ERROR); +} +} +} \ No newline at end of file diff --git a/distributed_camera/hdi_service/test/unittest/common/dstream_operator/mock_dstream_operator_callback.h b/distributed_camera/hdi_service/test/unittest/common/dstream_operator/mock_dstream_operator_callback.h new file mode 100644 index 0000000000000000000000000000000000000000..d41513a4c585d796a1594cc872e6082b94f02fa9 --- /dev/null +++ b/distributed_camera/hdi_service/test/unittest/common/dstream_operator/mock_dstream_operator_callback.h @@ -0,0 +1,52 @@ +/* + * Copyright (c) 2022 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. + */ + +#ifndef MOCK_DISTRIBUTED_STREAM_OPERATOR_CALLBACK_H +#define MOCK_DISTRIBUTED_STREAM_OPERATOR_CALLBACK_H + +#include "v1_0/istream_operator_callback.h" + +namespace OHOS { +namespace DistributedHardware { +using namespace OHOS::HDI::Camera::V1_0; +class MockDStreamOperatorCallback : public IStreamOperatorCallback { +public: + MockDStreamOperatorCallback() = default; + + virtual ~MockDStreamOperatorCallback() = default; + + int32_t OnCaptureStarted(int32_t captureId, const std::vector& streamIds) override + { + return 0; + } + + int32_t OnCaptureEnded(int32_t captureId, const std::vector& infos) override + { + return 0; + } + + int32_t OnCaptureError(int32_t captureId, const std::vector& infos) override + { + return 0; + } + + int32_t OnFrameShutter(int32_t captureId, const std::vector& streamIds, uint64_t timestamp) override + { + return 0; + } +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // MOCK_DISTRIBUTED_STREAM_OPERATOR_CALLBACK_H \ No newline at end of file