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 index a4871e1a3ecf7295c0adeee1a9bce1fdabb43dd4..a661dc43cff077eaac331fbb35e42a4d835460ed 100644 --- a/distributed_camera/hdi_service/test/unittest/common/dcamera_device/BUILD.gn +++ b/distributed_camera/hdi_service/test/unittest/common/dcamera_device/BUILD.gn @@ -24,6 +24,7 @@ config("module_private_config") { "${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/test/unittest/common/dstream_operator", "${distributedcamera_hdf_path}/hdi_service/include/utils", "${distributedcamera_hdf_path}/interfaces/hdi_ipc", "${distributedcamera_hdf_path}/interfaces/hdi_ipc/server/device", 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 index 002cea47ed62d20487d453f1e12efdd1078e6c52..9a12e1aa08f891f7753efce56a9697a15ca31bde 100644 --- 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 @@ -1,10 +1,10 @@ /* - * Copyright (c) 2022-2024 Huawei Device Co., Ltd. + * Copyright (c) 2022-2025 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 + * 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, @@ -14,13 +14,25 @@ */ #include +#include +#include #include "dcamera_device.h" - +#include "constants.h" // For METADATA_CAPACITY_MAX_SIZE +#include "mock_dcamera_provider.h" +#include "mock_icamera_device_callback.h" +#include "mock_dstream_operator_callback.h" +#include "v1_3/istream_operator_callback.h" // For IStreamOperatorCallback +#include "mock_dcamera_provider_callback.h" +#include "dcamera_host.h" +#include "v1_3/types.h" using namespace testing::ext; namespace OHOS { namespace DistributedHardware { + +std::string g_providerMockRet; + class DCameraDeviceTest : public testing::Test { public: static void SetUpTestCase(void); @@ -28,42 +40,23 @@ public: void SetUp(void); void TearDown(void); + void OpenDeviceSuccessfully(); + sptr dcameraDevice_ = nullptr; + sptr mockProvider_ = 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"], - "Position": "BACK", - "ProtocolVer": "1.0", - "MetaData": "", - "Photo": { - "OutputFormat": [2, 4], - "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"], - "4": ["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"] - } - }, - "Preview": { - "OutputFormat": [2, 3], - "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"] - } - }, - "Video": { - "OutputFormat": [2, 3], - "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"] - } - }})"; +constexpr const char* TEST_ABILITY = R"({"CodecType": ["avenc_mpeg4"], "Position": "BACK"})"; + +std::shared_ptr CreateHDFEvent(DCameraEventResult result) +{ + auto event = std::make_shared(); + event->type_ = DCameraEventType::DCAMERA_MESSAGE; + event->result_ = result; + return event; +} void DCameraDeviceTest::SetUpTestCase(void) { @@ -75,42 +68,80 @@ void DCameraDeviceTest::TearDownTestCase(void) void DCameraDeviceTest::SetUp(void) { + mockProvider_ = new MockDCameraProvider(); + MockDCameraProvider::SetInstance(mockProvider_); + DHBase dhBase = {TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0}; dcameraDevice_ = sptr(new (std::nothrow) DCameraDevice(dhBase, TEST_ABILITY, TEST_ABILITY)); + dcameraDevice_ = new DCameraDevice(dhBase, TEST_ABILITY, TEST_ABILITY); + + sptr providerCallback = new MockDCameraProviderCallback(); + dcameraDevice_->SetProviderCallback(providerCallback); + + std::string cameraId = std::string(TEST_DEVICE_ID) + "__" + std::string(TEST_CAMERA_DH_ID_0); + DCameraHost::GetInstance()->dCameraDeviceMap_[cameraId] = dcameraDevice_; + + g_providerMockRet = ""; } void DCameraDeviceTest::TearDown(void) { + if (dcameraDevice_ != nullptr) { + if (dcameraDevice_->IsOpened()) { + dcameraDevice_->Close(); + } + } + dcameraDevice_ = nullptr; + mockProvider_ = nullptr; + MockDCameraProvider::SetInstance(nullptr); + DCameraHost::GetInstance()->dCameraDeviceMap_.clear(); +} + +void DCameraDeviceTest::OpenDeviceSuccessfully() +{ + sptr callback = new HDI::Camera::V1_0::MockCameraDeviceCallback(); + + const std::chrono::milliseconds sleepDuration(100); + std::thread notifyThread([this, &sleepDuration]() { + std::this_thread::sleep_for(sleepDuration); + dcameraDevice_->Notify(CreateHDFEvent(DCameraEventResult::DCAMERA_EVENT_CHANNEL_CONNECTED)); + }); + + CamRetCode rc = dcameraDevice_->OpenDCamera(callback); + notifyThread.join(); + + ASSERT_EQ(rc, CamRetCode::NO_ERROR); + ASSERT_TRUE(dcameraDevice_->IsOpened()); } /** * @tc.name: dcamera_device_test_001 - * @tc.desc: Verify SetResultMode + * @tc.desc: Verify SetResultMode success * @tc.type: FUNC * @tc.require: AR */ HWTEST_F(DCameraDeviceTest, dcamera_device_test_001, TestSize.Level0) { - EXPECT_EQ(false, dcameraDevice_ == nullptr); + ASSERT_NE(dcameraDevice_, nullptr); ResultCallbackMode mode = PER_FRAME; int32_t rc = dcameraDevice_->SetResultMode(mode); - EXPECT_EQ(true, rc == CamRetCode::NO_ERROR); + EXPECT_EQ(rc, CamRetCode::NO_ERROR); } /** * @tc.name: dcamera_device_test_002 - * @tc.desc: Verify GetEnabledResults + * @tc.desc: Verify GetEnabledResults success * @tc.type: FUNC * @tc.require: AR */ HWTEST_F(DCameraDeviceTest, dcamera_device_test_002, TestSize.Level1) { - EXPECT_EQ(false, dcameraDevice_ == nullptr); + ASSERT_NE(dcameraDevice_, nullptr); std::vector results; int32_t rc = dcameraDevice_->GetEnabledResults(results); - EXPECT_EQ(true, rc == CamRetCode::NO_ERROR); + EXPECT_EQ(rc, CamRetCode::NO_ERROR); } /** @@ -121,15 +152,10 @@ HWTEST_F(DCameraDeviceTest, dcamera_device_test_002, TestSize.Level1) */ 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); + ASSERT_NE(dcameraDevice_, nullptr); + sptr streamOperator; + int32_t rc = dcameraDevice_->GetStreamOperator_V1_3(nullptr, streamOperator); + EXPECT_EQ(rc, CamRetCode::INVALID_ARGUMENT); } /** @@ -140,11 +166,9 @@ HWTEST_F(DCameraDeviceTest, dcamera_device_test_003, TestSize.Level1) */ 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); + ASSERT_NE(dcameraDevice_, nullptr); + CamRetCode rc = dcameraDevice_->OpenDCamera(nullptr); + EXPECT_EQ(rc, CamRetCode::INVALID_ARGUMENT); } /** @@ -155,7 +179,280 @@ HWTEST_F(DCameraDeviceTest, dcamera_device_test_004, TestSize.Level1) */ HWTEST_F(DCameraDeviceTest, dcamera_device_test_005, TestSize.Level1) { - EXPECT_EQ(false, dcameraDevice_ == nullptr); + ASSERT_NE(dcameraDevice_, nullptr); + sptr callback = new HDI::Camera::V1_0::MockCameraDeviceCallback(); + g_providerMockRet = "OpenSession_Fail"; + CamRetCode rc = dcameraDevice_->OpenDCamera(callback); + EXPECT_NE(rc, CamRetCode::NO_ERROR); + EXPECT_FALSE(dcameraDevice_->IsOpened()); +} + +/** + * @tc.name: dcamera_device_test_006 + * @tc.desc: Verify OpenDCamera success case + * @tc.type: FUNC + * @tc.require: AR + */ +HWTEST_F(DCameraDeviceTest, dcamera_device_test_006, TestSize.Level1) +{ + ASSERT_NE(dcameraDevice_, nullptr); + OpenDeviceSuccessfully(); +} + +/** + * @tc.name: dcamera_device_test_007 + * @tc.desc: Verify UpdateSettings when device is not opened + * @tc.type: FUNC + * @tc.require: AR + */ +HWTEST_F(DCameraDeviceTest, dcamera_device_test_007, TestSize.Level1) +{ + ASSERT_NE(dcameraDevice_, nullptr); + std::vector settings; + settings.push_back(1); + dcameraDevice_->isOpened_ = false; + int32_t rc = dcameraDevice_->UpdateSettings(settings); + EXPECT_EQ(rc, CamRetCode::CAMERA_CLOSED); +} + +/** + * @tc.name: dcamera_device_test_008 + * @tc.desc: Verify UpdateSettings when provider fails + * @tc.type: FUNC + * @tc.require: AR + */ +HWTEST_F(DCameraDeviceTest, dcamera_device_test_008, TestSize.Level1) +{ + // Setup + OpenDeviceSuccessfully(); + + // Test + g_providerMockRet = "UpdateSettings_Fail"; + std::vector settings; + settings.push_back(1); + dcameraDevice_->isOpened_ = true; + int32_t rc = dcameraDevice_->UpdateSettings(settings); + + // Verify + EXPECT_NE(rc, CamRetCode::CAMERA_CLOSED); +} + +/** + * @tc.name: dcamera_device_test_009 + * @tc.desc: Verify Notify with DCAMERA_EVENT_CHANNEL_DISCONNECTED event + * @tc.type: FUNC + * @tc.require: AR + */ +HWTEST_F(DCameraDeviceTest, dcamera_device_test_009, TestSize.Level1) +{ + // Setup + sptr callback = new HDI::Camera::V1_0::MockCameraDeviceCallback(); + dcameraDevice_->OpenDCamera(callback); + dcameraDevice_->Close(); + dcameraDevice_->isOpened_ = true; + dcameraDevice_->OpenDCamera(callback); + ASSERT_TRUE(dcameraDevice_->IsOpened()); + + // Test + dcameraDevice_->Notify(CreateHDFEvent(DCameraEventResult::DCAMERA_EVENT_CHANNEL_DISCONNECTED)); + + // Verify + EXPECT_EQ(callback->GetCallCount(), 1); + EXPECT_EQ(callback->GetLastErrorType(), ErrorType::DEVICE_DISCONNECT); + EXPECT_FALSE(dcameraDevice_->IsOpened()); +} + +/** + * @tc.name: dcamera_device_test_010 + * @tc.desc: Verify Close function + * @tc.type: FUNC + * @tc.require: AR + */ +HWTEST_F(DCameraDeviceTest, dcamera_device_test_010, TestSize.Level1) +{ + // Setup + OpenDeviceSuccessfully(); + ASSERT_TRUE(dcameraDevice_->IsOpened()); + + // Test + int32_t rc = dcameraDevice_->Close(); + + // Verify + EXPECT_EQ(rc, CamRetCode::NO_ERROR); + EXPECT_FALSE(dcameraDevice_->IsOpened()); +} + +/** + * @tc.name: dcamera_device_test_011 + * @tc.desc: Verify OnSettingsResult with null input + * @tc.type: FUNC + * @tc.require: AR + */ +HWTEST_F(DCameraDeviceTest, dcamera_device_test_011, TestSize.Level1) +{ + ASSERT_NE(dcameraDevice_, nullptr); + DCamRetCode ret = dcameraDevice_->OnSettingsResult(nullptr); + EXPECT_EQ(ret, DCamRetCode::INVALID_ARGUMENT); +} + +/** + * @tc.name: dcamera_device_test_012 + * @tc.desc: Verify EnableResult with invalid argument + * @tc.type: FUNC + * @tc.require: AR + */ +HWTEST_F(DCameraDeviceTest, dcamera_device_test_012, TestSize.Level1) +{ + ASSERT_NE(dcameraDevice_, nullptr); + std::vector emptyResults; + int32_t ret = dcameraDevice_->EnableResult(emptyResults); + EXPECT_EQ(ret, CamRetCode::DEVICE_ERROR); +} + +/** + * @tc.name: dcamera_device_test_013 + * @tc.desc: Verify UpdateSettings with empty settings vector + * @tc.type: FUNC + * @tc.require: AR + */ +HWTEST_F(DCameraDeviceTest, dcamera_device_test_013, TestSize.Level1) +{ + OpenDeviceSuccessfully(); + + std::vector emptySettings; + int32_t rc = dcameraDevice_->UpdateSettings(emptySettings); + EXPECT_EQ(rc, CamRetCode::INVALID_ARGUMENT); +} + +/** + * @tc.name: dcamera_device_test_014 + * @tc.desc: Verify UpdateSettings with oversized settings vector + * @tc.type: FUNC + * @tc.require: AR + */ +HWTEST_F(DCameraDeviceTest, dcamera_device_test_014, TestSize.Level1) +{ + OpenDeviceSuccessfully(); + std::vector oversizedSettings(METADATA_CAPACITY_MAX_SIZE + 1, 0); + int32_t rc = dcameraDevice_->UpdateSettings(oversizedSettings); + EXPECT_EQ(rc, CamRetCode::INVALID_ARGUMENT); +} + +/** + * @tc.name: dcamera_device_test_015 + * @tc.desc: Verify Notify with all other event types + * @tc.type: FUNC + * @tc.require: AR + */ +HWTEST_F(DCameraDeviceTest, dcamera_device_test_015, TestSize.Level1) +{ + sptr callback = new HDI::Camera::V1_0::MockCameraDeviceCallback(); + dcameraDevice_->OpenDCamera(callback); + dcameraDevice_->isOpened_ = true; + callback->Reset(); + dcameraDevice_->Notify(CreateHDFEvent(DCameraEventResult::DCAMERA_EVENT_OPEN_CHANNEL_ERROR)); + EXPECT_EQ(callback->GetCallCount(), 0); + + callback->Reset(); + dcameraDevice_->Notify(CreateHDFEvent(DCameraEventResult::DCAMERA_EVENT_CONFIG_STREAMS_ERROR)); + EXPECT_EQ(callback->GetLastErrorType(), ErrorType::REQUEST_TIMEOUT); + + callback->Reset(); + dcameraDevice_->Notify(CreateHDFEvent(DCameraEventResult::DCAMERA_EVENT_START_CAPTURE_ERROR)); + EXPECT_EQ(callback->GetLastErrorType(), ErrorType::REQUEST_TIMEOUT); + callback->Reset(); + dcameraDevice_->Notify(CreateHDFEvent(DCameraEventResult::DCAMERA_EVENT_DEVICE_ERROR)); + EXPECT_EQ(callback->GetLastErrorType(), ErrorType::DRIVER_ERROR); + + callback->Reset(); + auto ret = dcameraDevice_->Notify(CreateHDFEvent(DCameraEventResult::DCAMERA_EVENT_DEVICE_PREEMPT)); + EXPECT_EQ(ret, SUCCESS); + EXPECT_FALSE(dcameraDevice_->IsOpened()); + + dcameraDevice_->isOpened_ = true; + + callback->Reset(); + ret = dcameraDevice_->Notify(CreateHDFEvent(DCameraEventResult::DCAMERA_EVENT_DEVICE_IN_USE)); + EXPECT_EQ(ret, SUCCESS); + + callback->Reset(); + ret = dcameraDevice_->Notify(CreateHDFEvent(DCameraEventResult::DCAMERA_EVENT_NO_PERMISSION)); + EXPECT_EQ(ret, SUCCESS); +} + +/** + * @tc.name: dcamera_device_test_016 + * @tc.desc: Verify Notify and OnSettingsResult with invalid arguments + * @tc.type: FUNC + * @tc.require: AR + */ +HWTEST_F(DCameraDeviceTest, dcamera_device_test_016, TestSize.Level1) +{ + DCamRetCode rcNotify = dcameraDevice_->Notify(nullptr); + EXPECT_EQ(rcNotify, DCamRetCode::INVALID_ARGUMENT); + + auto event = std::make_shared(); + event->type_ = static_cast(99); + rcNotify = dcameraDevice_->Notify(event); + EXPECT_EQ(rcNotify, DCamRetCode::INVALID_ARGUMENT); + + auto settings = std::make_shared(); + settings->type_ = static_cast(99); + settings->value_ = "some_value"; + DCamRetCode rcSettings = dcameraDevice_->OnSettingsResult(settings); + EXPECT_EQ(rcSettings, DCamRetCode::INVALID_ARGUMENT); + + + settings->type_ = DCSettingsType::METADATA_RESULT; + settings->value_ = ""; + rcSettings = dcameraDevice_->OnSettingsResult(settings); + EXPECT_EQ(rcSettings, DCamRetCode::INVALID_ARGUMENT); +} + +/** + * @tc.name: dcamera_device_test_017 + * @tc.desc: Verify OpenDCamera timeout + * @tc.type: FUNC + * @tc.require: AR + */ +HWTEST_F(DCameraDeviceTest, dcamera_device_test_017, TestSize.Level2) +{ + // This test simulates a timeout by not sending the connected event. + sptr callback = new HDI::Camera::V1_0::MockCameraDeviceCallback(); + CamRetCode rc = dcameraDevice_->OpenDCamera(callback); + EXPECT_EQ(rc, CamRetCode::DEVICE_ERROR); +} +/** + * @tc.name: dcamera_device_test_018 + * @tc.desc: Verify GetStreamOperator fails when stream operator is null + * @tc.type: FUNC + * @tc.require: AR + */ +HWTEST_F(DCameraDeviceTest, dcamera_device_test_018, TestSize.Level1) +{ + OHOS::sptr callback(new (std::nothrow) MockDStreamOperatorCallback()); + sptr streamOperator; + dcameraDevice_->dCameraStreamOperator_ = nullptr; + int32_t rc = dcameraDevice_->GetStreamOperator(callback, streamOperator); + EXPECT_EQ(rc, CamRetCode::DEVICE_ERROR); +} + +/** + * @tc.name: dcamera_device_test_019 + * @tc.desc: Verify metadata-related functions fail when metadata processor is null + * @tc.type: FUNC + * @tc.require: AR + */ +HWTEST_F(DCameraDeviceTest, dcamera_device_test_019, TestSize.Level1) +{ + dcameraDevice_->dMetadataProcessor_ = nullptr; + ResultCallbackMode mode = PER_FRAME; + int32_t re = dcameraDevice_->SetResultMode(mode); + EXPECT_EQ(re, CamRetCode::DEVICE_ERROR); + + std::vector results; + re = dcameraDevice_->GetEnabledResults(results); + EXPECT_EQ(re, CamRetCode::DEVICE_ERROR); std::shared_ptr ability = nullptr; std::string sinkAbility = "sink"; @@ -165,7 +462,60 @@ HWTEST_F(DCameraDeviceTest, dcamera_device_test_005, TestSize.Level1) dcameraDevice_->SetDcameraAbility(TEST_ABILITY); rc = dcameraDevice_->GetDCameraAbility(ability); - EXPECT_EQ(true, rc == CamRetCode::NO_ERROR); + EXPECT_NE(rc, CamRetCode::NO_ERROR); + results.push_back(1); + int32_t result = dcameraDevice_->EnableResult(results); + EXPECT_EQ(result, CamRetCode::DEVICE_ERROR); + result = dcameraDevice_->DisableResult(results); + EXPECT_EQ(result, CamRetCode::DEVICE_ERROR); + + auto settingsResult = std::make_shared(); + settingsResult->type_ = DCSettingsType::METADATA_RESULT; + settingsResult->value_ = "some_value"; + DCamRetCode ret = dcameraDevice_->OnSettingsResult(settingsResult); + EXPECT_EQ(ret, DCamRetCode::DEVICE_NOT_INIT); +} + +/** + * @tc.name: dcamera_device_test_020 + * @tc.desc: Verify OpenDCamera fails when DCameraProvider is null + * @tc.type: FUNC + * @tc.require: AR + */ +HWTEST_F(DCameraDeviceTest, dcamera_device_test_020, TestSize.Level1) +{ + MockDCameraProvider::SetInstance(nullptr); + sptr callback = new HDI::Camera::V1_0::MockCameraDeviceCallback(); + CamRetCode rc = dcameraDevice_->OpenDCamera(callback); + EXPECT_EQ(rc, CamRetCode::DEVICE_ERROR); +} + +/** + * @tc.name: dcamera_device_test_021 + * @tc.desc: Verify Close fails when DCameraProvider is null + * @tc.type: FUNC + * @tc.require: AR + */ +HWTEST_F(DCameraDeviceTest, dcamera_device_test_021, TestSize.Level1) +{ + OpenDeviceSuccessfully(); + MockDCameraProvider::SetInstance(nullptr); + int32_t rc = dcameraDevice_->Close(); + EXPECT_EQ(rc, CamRetCode::NO_ERROR); +} + +/** + * @tc.name: dcamera_device_test_022 + * @tc.desc: Verify DisableResult with invalid oversized vector + * @tc.type: FUNC + * @tc.require: AR + */ +HWTEST_F(DCameraDeviceTest, dcamera_device_test_022, TestSize.Level1) +{ + ASSERT_NE(dcameraDevice_, nullptr); + std::vector oversizedResults(METADATA_CAPACITY_MAX_SIZE + 1, 0); + int32_t ret = dcameraDevice_->DisableResult(oversizedResults); + EXPECT_EQ(ret, CamRetCode::DEVICE_ERROR); } } } \ No newline at end of file diff --git a/distributed_camera/hdi_service/test/unittest/common/dcamera_device/mock_dcamera_provider.h b/distributed_camera/hdi_service/test/unittest/common/dcamera_device/mock_dcamera_provider.h new file mode 100644 index 0000000000000000000000000000000000000000..48486e940ccbe5586f4de7e3fb035551adb76bab --- /dev/null +++ b/distributed_camera/hdi_service/test/unittest/common/dcamera_device/mock_dcamera_provider.h @@ -0,0 +1,66 @@ +/* + * Copyright (c) 2025 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 OHOS_MOCK_DCAMERA_PROVIDER_H +#define OHOS_MOCK_DCAMERA_PROVIDER_H + +#include "dcamera_provider.h" + +namespace OHOS { +namespace DistributedHardware { + +extern std::string g_providerMockRet; + +class MockDCameraProvider : public DCameraProvider { +public: + MockDCameraProvider() = default; + ~MockDCameraProvider() = default; + + static void SetInstance(const sptr& instance) + { + DCameraProvider::instance_ = instance; + } + + int32_t OpenSession(const DHBase& dhBase) + { + if (g_providerMockRet == "OpenSession_Fail") { + return DCamRetCode::FAILED; + } + return CamRetCode::NO_ERROR; + } + + int32_t CloseSession(const DHBase& dhBase) + { + return CamRetCode::NO_ERROR; + } + + int32_t UpdateSettings(const DHBase& dhBase, const std::vector& settings) + { + if (g_providerMockRet == "UpdateSettings_Fail") { + return DCamRetCode::FAILED; + } + return CamRetCode::NO_ERROR; + } + + int32_t StopCapture(const DHBase& dhBase, const std::vector& streamIds) + { + return CamRetCode::NO_ERROR; + } +}; + +} // namespace DistributedHardware +} // namespace OHOS + +#endif // OHOS_MOCK_DCAMERA_PROVIDER_H diff --git a/distributed_camera/hdi_service/test/unittest/common/dcamera_device/mock_dcamera_provider_callback.h b/distributed_camera/hdi_service/test/unittest/common/dcamera_device/mock_dcamera_provider_callback.h new file mode 100644 index 0000000000000000000000000000000000000000..cb9ee8f4f023c737d7fe8fe6c20d9534cae85ec1 --- /dev/null +++ b/distributed_camera/hdi_service/test/unittest/common/dcamera_device/mock_dcamera_provider_callback.h @@ -0,0 +1,52 @@ +/* + * Copyright (c) 2025 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_DCAMERA_PROVIDER_CALLBACK_H +#define MOCK_DCAMERA_PROVIDER_CALLBACK_H + +#include "v1_1/id_camera_provider_callback.h" + +namespace OHOS { +namespace DistributedHardware { + +using namespace OHOS::HDI::DistributedCamera::V1_1; + +class MockDCameraProviderCallback : public IDCameraProviderCallback { +public: + MockDCameraProviderCallback() = default; + virtual ~MockDCameraProviderCallback() = default; + + int32_t OpenSession(const DHBase& dhBase) { return DCamRetCode::SUCCESS; } + int32_t CloseSession(const DHBase& dhBase) { return DCamRetCode::SUCCESS; } + int32_t ConfigureStreams(const DHBase& dhBase, const std::vector& streamInfos) + { + return DCamRetCode::SUCCESS; + } + int32_t ReleaseStreams(const DHBase& dhBase, const std::vector& streamIds) { return DCamRetCode::SUCCESS; } + int32_t StartCapture(const DHBase& dhBase, const std::vector& captureInfos) + { + return DCamRetCode::SUCCESS; + } + int32_t StopCapture(const DHBase& dhBase, const std::vector& streamIds) { return DCamRetCode::SUCCESS; } + int32_t UpdateSettings(const DHBase& dhBase, const std::vector& settings) + { + return DCamRetCode::SUCCESS; + } + int32_t NotifyEvent(const DHBase& dhBase, const DCameraHDFEvent& event) { return DCamRetCode::SUCCESS; } +}; + +} // namespace DistributedHardware +} // namespace OHOS +#endif // MOCK_DCAMERA_PROVIDER_CALLBACK_H \ No newline at end of file diff --git a/distributed_camera/hdi_service/test/unittest/common/dcamera_device/mock_dstream_operator.h b/distributed_camera/hdi_service/test/unittest/common/dcamera_device/mock_dstream_operator.h new file mode 100644 index 0000000000000000000000000000000000000000..2d0e5c8c88383b51427226df4c3299e7ec507fe6 --- /dev/null +++ b/distributed_camera/hdi_service/test/unittest/common/dcamera_device/mock_dstream_operator.h @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2025 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 OHOS_MOCK_DSTREAM_OPERATOR_H +#define OHOS_MOCK_DSTREAM_OPERATOR_H + +#include "dstream_operator.h" +#include + +namespace OHOS { +namespace DistributedHardware { +class MockDStreamOperator : public DStreamOperator { +public: + MockDStreamOperator() : DStreamOperator(nullptr) {} + + MOCK_METHOD(DCamRetCode, SetOutputVal, (const DHBase&, const std::string&, const std::string&), (override)); + MOCK_METHOD(DCamRetCode, SetCallBack, (const sptr&), (override)); + MOCK_METHOD(DCamRetCode, SetCallBack_V1_2, (const sptr&), (override)); + MOCK_METHOD(DCamRetCode, SetCallBack_V1_3, (const sptr&), (override)); + MOCK_METHOD(void, SetDeviceCallback, (const ErrorCallback&, const ResultCallback&), (override)); + MOCK_METHOD(std::vector, GetStreamIds, (), (override)); + MOCK_METHOD(DCamRetCode, AcquireBuffer, (int, DCameraBuffer&), (override)); + MOCK_METHOD(DCamRetCode, ShutterBuffer, (int, const DCameraBuffer&), (override)); + MOCK_METHOD(void, Release, (), (override)); +}; +} +} +#endif diff --git a/distributed_camera/hdi_service/test/unittest/common/dcamera_device/mock_icamera_device_callback.h b/distributed_camera/hdi_service/test/unittest/common/dcamera_device/mock_icamera_device_callback.h new file mode 100644 index 0000000000000000000000000000000000000000..dc0348fb70038838cab707203958318ff04ad5fd --- /dev/null +++ b/distributed_camera/hdi_service/test/unittest/common/dcamera_device/mock_icamera_device_callback.h @@ -0,0 +1,61 @@ +/* + * Copyright (c) 2025 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 OHOS_MOCK_ICAMERA_DEVICE_CALLBACK_H +#define OHOS_MOCK_ICAMERA_DEVICE_CALLBACK_H + +#include "v1_0/icamera_device_callback.h" + +namespace OHOS { +namespace HDI { +namespace Camera { +namespace V1_0 { + +class MockCameraDeviceCallback : public ICameraDeviceCallback { +public: + MockCameraDeviceCallback() = default; + virtual ~MockCameraDeviceCallback() = default; + + int32_t OnError(ErrorType type, int32_t errorMsg) override + { + lastErrorType_ = type; + lastErrorMsg_ = errorMsg; + callCount_++; + return 0; + } + + int32_t OnResult(uint64_t timestamp, const std::vector& result) override + { + return 0; + } + + ErrorType GetLastErrorType() const { return lastErrorType_; } + int32_t GetCallCount() const { return callCount_; } + void Reset() + { + lastErrorType_ = (ErrorType)-1; + callCount_ = 0; + } + +private: + ErrorType lastErrorType_ = (ErrorType)-1; + int32_t lastErrorMsg_ = 0; + int32_t callCount_ = 0; +}; + +} // V1_0 +} // Camera +} // HDI +} // OHOS +#endif // OHOS_MOCK_ICAMERA_DEVICE_CALLBACK_H diff --git a/distributed_camera/hdi_service/test/unittest/common/dcamera_provider/dcamera_provider_test.cpp b/distributed_camera/hdi_service/test/unittest/common/dcamera_provider/dcamera_provider_test.cpp index 9039ac12da46c6fe5177a200bc859752c7b683dd..ef96d0092bcf2437bf6b24408fcfe98b2c72cefd 100644 --- a/distributed_camera/hdi_service/test/unittest/common/dcamera_provider/dcamera_provider_test.cpp +++ b/distributed_camera/hdi_service/test/unittest/common/dcamera_provider/dcamera_provider_test.cpp @@ -182,6 +182,7 @@ HWTEST_F(DcameraProviderTest, AcquireBuffer_001, TestSize.Level1) DHBase dhBase; int32_t streamId = 0; DCameraBuffer buffer; + DCameraHost::GetInstance()->dCameraDeviceMap_.clear(); auto ret = DCameraProvider::GetInstance()->AcquireBuffer(dhBase, streamId, buffer); EXPECT_EQ(ret, DCamRetCode::INVALID_ARGUMENT); } @@ -527,5 +528,81 @@ HWTEST_F(DcameraProviderTest, GetDCameraDevice_001, TestSize.Level1) auto ret = DCameraProvider::GetInstance()->GetDCameraDevice(dhBase); EXPECT_EQ(ret, nullptr); } + +/** + * @tc.name: AcquireBuffer_004 + * @tc.desc: Verify AcquireBuffer + * @tc.type: FUNC + * @tc.require: AR + */ +HWTEST_F(DcameraProviderTest, AcquireBuffer_004, TestSize.Level1) +{ + DHBase dhBase; + int32_t streamId = 1; + DCameraBuffer buffer; + dhBase.deviceId_ = "deviceId"; + dhBase.dhId_ = "dhId"; + + OHOS::sptr dCamera(new (std::nothrow) DCameraDevice(dhBase, "sinkAbilityInfo", + "sourceCodecInfo")); + dCamera->dCameraStreamOperator_ = nullptr; + std::string str = "deviceId__dhId"; + DCameraHost::GetInstance()->dCameraDeviceMap_[str] = dCamera; + auto ret = DCameraProvider::GetInstance()->AcquireBuffer(dhBase, streamId, buffer); + EXPECT_NE(ret, DCamRetCode::SUCCESS); +} + +/** + * @tc.name: ShutterBuffer_004 + * @tc.desc: Verify ShutterBuffer + * @tc.type: FUNC + * @tc.require: AR + */ +HWTEST_F(DcameraProviderTest, ShutterBuffer_004, TestSize.Level1) +{ + DHBase dhBase; + int32_t streamId = 1; + DCameraBuffer buffer; + buffer.index_ = 1; + buffer.size_ = 1; + dhBase.deviceId_ = "deviceId"; + dhBase.dhId_ = "dhId"; + auto ret = DCameraProvider::GetInstance()->ShutterBuffer(dhBase, streamId, buffer); + EXPECT_EQ(ret, DCamRetCode::DEVICE_NOT_INIT); +} + +/** + * @tc.name: OnSettingsResult_004 + * @tc.desc: Verify OnSettingsResult + * @tc.type: FUNC + * @tc.require: AR + */ +HWTEST_F(DcameraProviderTest, OnSettingsResult_004, TestSize.Level1) +{ + DHBase dhBase; + DCameraSettings result; + dhBase.deviceId_ = "deviceId"; + dhBase.dhId_ = "dhId"; + result.value_ = "value"; + auto ret = DCameraProvider::GetInstance()->OnSettingsResult(dhBase, result); + EXPECT_NE(ret, DCamRetCode::SUCCESS); +} + +/** + * @tc.name: Notify_005 + * @tc.desc: Verify Notify + * @tc.type: FUNC + * @tc.require: AR + */ +HWTEST_F(DcameraProviderTest, Notify_005, TestSize.Level1) +{ + DHBase dhBase; + DCameraHDFEvent event; + dhBase.deviceId_ = "deviceId"; + dhBase.dhId_ = "dhId"; + event.content_ = "content"; + auto ret = DCameraProvider::GetInstance()->Notify(dhBase, event); + EXPECT_NE(ret, DCamRetCode::DEVICE_NOT_INIT); +} } } \ No newline at end of file