diff --git a/services/cameraservice/sinkservice/test/unittest/common/distributedcamera/BUILD.gn b/services/cameraservice/sinkservice/test/unittest/common/distributedcamera/BUILD.gn index c0317464da3e199cb672fcbfc2cbaa900cb2dc20..5a4a12cd1ccfe99340d0647f11213a21ee24c8c2 100644 --- a/services/cameraservice/sinkservice/test/unittest/common/distributedcamera/BUILD.gn +++ b/services/cameraservice/sinkservice/test/unittest/common/distributedcamera/BUILD.gn @@ -42,13 +42,17 @@ config("module_private_config") { "${innerkits_path}/native_cpp/camera_sink/include", "${services_path}/cameraservice/base/include", "${services_path}/cameraservice/cameraoperator/handler/include", + "${services_path}/cameraservice/sinkservice/include/distributedcamera", ] } ohos_unittest("DistributedCameraSinkServiceTest") { module_out_path = module_out_path - sources = [ "distributed_camera_sink_service_test.cpp" ] + sources = [ + "dcamera_sink_hidumper_test.cpp", + "distributed_camera_sink_service_test.cpp", + ] configs = [ ":module_private_config" ] @@ -58,6 +62,7 @@ ohos_unittest("DistributedCameraSinkServiceTest") { "${graphicstandard_path}:libsurface", "${innerkits_path}/native_cpp/camera_sink:distributed_camera_sink_sdk", "${services_path}/cameraservice/cameraoperator/handler:distributed_camera_handler", + "${services_path}/cameraservice/sinkservice:distributed_camera_sink", "//drivers/peripheral/camera/interfaces/metadata:metadata", "//third_party/googletest:gtest_main", "//third_party/jsoncpp:jsoncpp", diff --git a/services/cameraservice/sinkservice/test/unittest/common/distributedcamera/dcamera_sink_hidumper_test.cpp b/services/cameraservice/sinkservice/test/unittest/common/distributedcamera/dcamera_sink_hidumper_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..a278b824ded3db839c48a1643582311967a6bcc9 --- /dev/null +++ b/services/cameraservice/sinkservice/test/unittest/common/distributedcamera/dcamera_sink_hidumper_test.cpp @@ -0,0 +1,155 @@ +/* + * 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_sink_hidumper.h" +#include "distributed_hardware_log.h" + +using namespace testing::ext; + +namespace OHOS { +namespace DistributedHardware { +class DcameraSinkHidumperTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); +}; + +void DcameraSinkHidumperTest::SetUpTestCase(void) +{ + DHLOGI("DcameraSinkHidumperTest::SetUpTestCase"); +} + +void DcameraSinkHidumperTest::TearDownTestCase(void) +{ + DHLOGI("DcameraSinkHidumperTest::TearDownTestCase"); +} + +void DcameraSinkHidumperTest::SetUp(void) +{ + DHLOGI("DcameraSinkHidumperTest::SetUp"); +} + +void DcameraSinkHidumperTest::TearDown(void) +{ + DHLOGI("DcameraSinkHidumperTest::TearDown"); +} + +/** + * @tc.name: dcamera_sink_hidumper_test_001 + * @tc.desc: Verify the Dump function. + * @tc.type: FUNC + * @tc.require: issue + */ +HWTEST_F(DcameraSinkHidumperTest, dcamera_sink_hidumper_test_001, TestSize.Level1) +{ + DHLOGI("DcameraSinkHidumperTest::dcamera_sink_hidumper_test_001"); + std::vector args; + std::string result; + bool ret = DcameraSinkHidumper::GetInstance().Dump(args, result); + EXPECT_EQ(true, ret); +} + +/** + * @tc.name: dcamera_sink_hidumper_test_002 + * @tc.desc: Verify the Dump function. + * @tc.type: FUNC + * @tc.require: issue + */ +HWTEST_F(DcameraSinkHidumperTest, dcamera_sink_hidumper_test_002, TestSize.Level1) +{ + DHLOGI("DcameraSinkHidumperTest::dcamera_sink_hidumper_test_002"); + std::vector args; + std::string str1 = "--version"; + std::string str2 = "--camNum"; + args.push_back(str1); + args.push_back(str2); + std::string result; + bool ret = DcameraSinkHidumper::GetInstance().Dump(args, result); + EXPECT_EQ(true, ret); +} + +/** + * @tc.name: dcamera_sink_hidumper_test_003 + * @tc.desc: Verify the Dump function. + * @tc.type: FUNC + * @tc.require: issue + */ +HWTEST_F(DcameraSinkHidumperTest, dcamera_sink_hidumper_test_003, TestSize.Level1) +{ + DHLOGI("DcameraSinkHidumperTest::dcamera_sink_hidumper_test_003"); + std::vector args; + std::string str1 = "--version"; + args.push_back(str1); + std::string result; + bool ret = DcameraSinkHidumper::GetInstance().Dump(args, result); + EXPECT_EQ(true, ret); +} + +/** + * @tc.name: dcamera_sink_hidumper_test_004 + * @tc.desc: Verify the Dump function. + * @tc.type: FUNC + * @tc.require: issue + */ +HWTEST_F(DcameraSinkHidumperTest, dcamera_sink_hidumper_test_004, TestSize.Level1) +{ + DHLOGI("DcameraSinkHidumperTest::dcamera_sink_hidumper_test_004"); + std::vector args; + std::string str1 = "--camNum"; + args.push_back(str1); + std::string result; + bool ret = DcameraSinkHidumper::GetInstance().Dump(args, result); + EXPECT_EQ(true, ret); +} + +/** + * @tc.name: dcamera_sink_hidumper_test_005 + * @tc.desc: Verify the Dump function. + * @tc.type: FUNC + * @tc.require: issue + */ +HWTEST_F(DcameraSinkHidumperTest, dcamera_sink_hidumper_test_005, TestSize.Level1) +{ + DHLOGI("DcameraSinkHidumperTest::dcamera_sink_hidumper_test_005"); + std::vector args; + std::string str1 = "--opened"; + args.push_back(str1); + std::string result; + bool ret = DcameraSinkHidumper::GetInstance().Dump(args, result); + EXPECT_EQ(true, ret); +} + +/** + * @tc.name: dcamera_sink_hidumper_test_006 + * @tc.desc: Verify the Dump function. + * @tc.type: FUNC + * @tc.require: issue + */ +HWTEST_F(DcameraSinkHidumperTest, dcamera_sink_hidumper_test_006, TestSize.Level1) +{ + DHLOGI("DcameraSinkHidumperTest::dcamera_sink_hidumper_test_006"); + std::vector args; + std::string str1 = "-h"; + args.push_back(str1); + std::string result; + bool ret = DcameraSinkHidumper::GetInstance().Dump(args, result); + EXPECT_EQ(true, ret); +} +} // namespace DistributedHardware +} // namespace OHOS \ No newline at end of file diff --git a/services/cameraservice/sourceservice/test/unittest/BUILD.gn b/services/cameraservice/sourceservice/test/unittest/BUILD.gn index 6194e64f0c4f6504d7be7215299be80d08b7bf09..6df37a674a0f30fbd35ae0697500ba2ef0be48e6 100644 --- a/services/cameraservice/sourceservice/test/unittest/BUILD.gn +++ b/services/cameraservice/sourceservice/test/unittest/BUILD.gn @@ -13,5 +13,8 @@ group("source_service_test") { testonly = true - deps = [ "common/distributedcameramgr:dcamera_mgr_test" ] + deps = [ + "common/distributedcamera:dcamera_source_test", + "common/distributedcameramgr:dcamera_source_mgr_test", + ] } diff --git a/services/cameraservice/sourceservice/test/unittest/common/distributedcamera/BUILD.gn b/services/cameraservice/sourceservice/test/unittest/common/distributedcamera/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..85de4ddb860f65e0a21659e7385bffaa08602bb3 --- /dev/null +++ b/services/cameraservice/sourceservice/test/unittest/common/distributedcamera/BUILD.gn @@ -0,0 +1,97 @@ +# Copyright (c) 2021 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/test.gni") +import( + "//foundation/distributedhardware/distributed_camera/distributedcamera.gni") + +module_out_path = "distributed_camera/dcamera_source_test" + +config("module_private_config") { + visibility = [ ":*" ] + include_dirs = [ + "${services_path}/cameraservice/sourceservice/include/distributedcamera", + "${services_path}/cameraservice/sourceservice/include/distributedcameramgr", + "${services_path}/cameraservice/sourceservice/include/distributedcameramgr/dcameracontrol", + "${services_path}/cameraservice/sourceservice/include/distributedcameramgr/dcameradata", + "${services_path}/cameraservice/sourceservice/include/distributedcameramgr/dcamerahdf", + "${services_path}/cameraservice/sourceservice/include/distributedcameramgr/dcamerainterface", + "${services_path}/cameraservice/sourceservice/include/distributedcameramgr/dcamerastate", + "${services_path}/cameraservice/cameraoperator/client/include", + "${services_path}/cameraservice/base/include", + "${services_path}/channel/include", + "${services_path}/data_process/include/pipeline", + "${services_path}/data_process/include/interfaces", + "${services_path}/data_process/include/utils", + "${services_path}/data_process/include/eventbus", + "${common_path}/include/constants", + "${common_path}/include/utils", + + "${innerkits_path}/native_cpp/camera_source/include", + "${innerkits_path}/native_cpp/camera_source/include/callback", + "${innerkits_path}/native_cpp/camera_sink/include", + + "${fwk_utils_path}/include", + "${fwk_utils_path}/include/eventbus", + "${fwk_common_path}/utils/include", + "//commonlibrary/c_utils/base/include", + "//utils/system/safwk/native/include", + "//third_party/jsoncpp/include", + "//drivers/peripheral/base/", + "${graphicstandard_path}/frameworks/surface/include", + ] +} + +ohos_unittest("DCameraSourceTest") { + module_out_path = module_out_path + + sources = [ + "dcamera_service_state_listener_test.cpp", + "dcamera_source_callback proxy_test.cpp", + "dcamera_source_hidumper_test.cpp", + "distributed_camera_source_service_test.cpp", + ] + + configs = [ ":module_private_config" ] + + deps = [ + "${common_path}:distributed_camera_utils", + "${graphicstandard_path}:libsurface", + "${innerkits_path}/native_cpp/camera_source:distributed_camera_source_sdk", + "${services_path}/cameraservice/sourceservice:distributed_camera_source", + "${services_path}/channel:distributed_camera_channel", + "//third_party/googletest:gtest_main", + "//third_party/jsoncpp:jsoncpp", + ] + + external_deps = [ + "c_utils:utils", + "drivers_interface_distributed_camera:libdistributed_camera_provider_proxy_1.0", + "dsoftbus:softbus_client", + "eventhandler:libeventhandler", + "hiviewdfx_hilog_native:libhilog", + "ipc:ipc_core", + "samgr:samgr_proxy", + ] + + defines = [ + "HI_LOG_ENABLE", + "DH_LOG_TAG=\"DCameraSourceTest\"", + "LOG_DOMAIN=0xD004100", + ] +} + +group("dcamera_source_test") { + testonly = true + deps = [ ":DCameraSourceTest" ] +} diff --git a/services/cameraservice/sourceservice/test/unittest/common/distributedcamera/dcamera_service_state_listener_test.cpp b/services/cameraservice/sourceservice/test/unittest/common/distributedcamera/dcamera_service_state_listener_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..650206e9608c3e12f15200a868b33962878f4d7e --- /dev/null +++ b/services/cameraservice/sourceservice/test/unittest/common/distributedcamera/dcamera_service_state_listener_test.cpp @@ -0,0 +1,110 @@ +/* + * 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_service_state_listener.h" +#include "dcamera_source_callback.h" +#include "distributed_camera_errno.h" +#include "distributed_hardware_log.h" + +using namespace testing::ext; + +namespace OHOS { +namespace DistributedHardware { +class DcameraServiceStateListenerTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); + + std::shared_ptr testListener_; +}; + +namespace { +const std::string TEST_DEVICE_ID = "bb536a637105409e904d4da83790a4a7"; +const std::string TEST_CAMERA_DH_ID_0 = "camera_0"; +const std::string TEST_REQID = "bb536a637105409e904d4da83790a4a7"; +std::string TEST_ATTRS = ""; +} + +void DcameraServiceStateListenerTest::SetUpTestCase(void) +{ + DHLOGI("DcameraServiceStateListenerTest::SetUpTestCase"); +} + +void DcameraServiceStateListenerTest::TearDownTestCase(void) +{ + DHLOGI("DcameraServiceStateListenerTest::TearDownTestCase"); +} + +void DcameraServiceStateListenerTest::SetUp(void) +{ + DHLOGI("DcameraServiceStateListenerTest::SetUp"); + testListener_ = std::make_shared(); +} + +void DcameraServiceStateListenerTest::TearDown(void) +{ + DHLOGI("DcameraServiceStateListenerTest::TearDown"); + testListener_ = nullptr; +} + +/** + * @tc.name: dcamera_service_state_listener_test_001 + * @tc.desc: Verify the OnRegisterNotify OnUnregisterNotify function. + * @tc.type: FUNC + * @tc.require: issue + */ +HWTEST_F(DcameraServiceStateListenerTest, dcamera_service_state_listener_test_001, TestSize.Level1) +{ + DHLOGI("DcameraServiceStateListenerTest::dcamera_service_state_listener_test_001"); + EXPECT_EQ(false, testListener_ == nullptr); + + int32_t status = 0; + int32_t ret = testListener_->OnRegisterNotify(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, TEST_REQID, status, TEST_ATTRS); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = testListener_->OnUnregisterNotify(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, TEST_REQID, status, TEST_ATTRS); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); +} + +/** + * @tc.name: dcamera_service_state_listener_test_002 + * @tc.desc: Verify the OnRegisterNotify OnUnregisterNotify function. + * @tc.type: FUNC + * @tc.require: issue + */ +HWTEST_F(DcameraServiceStateListenerTest, dcamera_service_state_listener_test_002, TestSize.Level1) +{ + DHLOGI("DcameraServiceStateListenerTest::dcamera_service_state_listener_test_002"); + EXPECT_EQ(false, testListener_ == nullptr); + + sptr callback = new DCameraSourceCallback(); + testListener_->SetCallback(callback); + + int32_t status = 0; + int32_t ret = testListener_->OnRegisterNotify(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, TEST_REQID, status, TEST_ATTRS); + EXPECT_EQ(DCAMERA_OK, ret); + + status = 1; + ret = testListener_->OnUnregisterNotify(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, TEST_REQID, status, TEST_ATTRS); + EXPECT_EQ(DCAMERA_OK, ret); + + callback = nullptr; +} +} // namespace DistributedHardware +} // namespace OHOS \ No newline at end of file diff --git a/services/cameraservice/sourceservice/test/unittest/common/distributedcamera/dcamera_source_callback proxy_test.cpp b/services/cameraservice/sourceservice/test/unittest/common/distributedcamera/dcamera_source_callback proxy_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..d68f989c5aa0024c37a73d56057b4b884dd35eb4 --- /dev/null +++ b/services/cameraservice/sourceservice/test/unittest/common/distributedcamera/dcamera_source_callback proxy_test.cpp @@ -0,0 +1,136 @@ +/* + * 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_source_callback_proxy.h" +#include "distributed_camera_errno.h" +#include "distributed_camera_constants.h" +#include "distributed_camera_source_proxy.h" +#include "distributed_hardware_log.h" +#include "if_system_ability_manager.h" +#include "iservice_registry.h" + +using namespace testing::ext; + +namespace OHOS { +namespace DistributedHardware { +class DcameraSourceCallbackProxyTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); +}; + +namespace { +const std::string TEST_DEVICE_ID = "bb536a637105409e904d4da83790a4a7"; +const std::string TEST_CAMERA_DH_ID_0 = "camera_0"; +const std::string TEST_REQID = "bb536a637105409e904d4da83790a4a7"; +std::string TEST_ATTRS = ""; +} + +void DcameraSourceCallbackProxyTest::SetUpTestCase(void) +{ + DHLOGI("DcameraSourceCallbackProxyTest::SetUpTestCase"); +} + +void DcameraSourceCallbackProxyTest::TearDownTestCase(void) +{ + DHLOGI("DcameraSourceCallbackProxyTest::TearDownTestCase"); +} + +void DcameraSourceCallbackProxyTest::SetUp(void) +{ + DHLOGI("DcameraSourceCallbackProxyTest::SetUp"); +} + +void DcameraSourceCallbackProxyTest::TearDown(void) +{ + DHLOGI("DcameraSourceCallbackProxyTest::TearDown"); +} + +/** + * @tc.name: dcamera_source_callback_proxy_test_001 + * @tc.desc: Verify the OnNotifyRegResult OnNotifyUnregResult function. + * @tc.type: FUNC + * @tc.require: issue + */ +HWTEST_F(DcameraSourceCallbackProxyTest, dcamera_source_callback_proxy_test_001, TestSize.Level1) +{ + DHLOGI("DcameraSourceCallbackProxyTest::dcamera_source_callback_proxy_test_001"); + sptr samgr = + SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); + sptr remoteObject = samgr->GetSystemAbility(DISTRIBUTED_HARDWARE_CAMERA_SOURCE_SA_ID); + sptr callbackProxy(new DCameraSourceCallbackProxy(remoteObject)); + EXPECT_EQ(false, callbackProxy == nullptr); + + const std::string devId = ""; + int32_t status = 0; + int32_t ret = callbackProxy->OnNotifyRegResult(devId, TEST_CAMERA_DH_ID_0, TEST_REQID, status, TEST_ATTRS); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = callbackProxy->OnNotifyUnregResult(devId, TEST_CAMERA_DH_ID_0, TEST_REQID, status, TEST_ATTRS); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); +} + +/** + * @tc.name: dcamera_source_callback_proxy_test_002 + * @tc.desc: Verify the OnNotifyRegResult OnNotifyUnregResult function. + * @tc.type: FUNC + * @tc.require: issue + */ +HWTEST_F(DcameraSourceCallbackProxyTest, dcamera_source_callback_proxy_test_002, TestSize.Level1) +{ + DHLOGI("DcameraSourceCallbackProxyTest::dcamera_source_callback_proxy_test_002"); + sptr samgr = + SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); + sptr remoteObject = samgr->GetSystemAbility(DISTRIBUTED_HARDWARE_CAMERA_SOURCE_SA_ID); + sptr callbackProxy(new DCameraSourceCallbackProxy(remoteObject)); + EXPECT_EQ(false, callbackProxy == nullptr); + + const std::string reqId = ""; + int32_t status = 0; + int32_t ret = callbackProxy->OnNotifyRegResult(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, reqId, status, TEST_ATTRS); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); + + ret = callbackProxy->OnNotifyUnregResult(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, reqId, status, TEST_ATTRS); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); +} + +/** + * @tc.name: dcamera_source_callback_proxy_test_003 + * @tc.desc: Verify the OnNotifyRegResult OnNotifyUnregResult function. + * @tc.type: FUNC + * @tc.require: issue + */ +HWTEST_F(DcameraSourceCallbackProxyTest, dcamera_source_callback_proxy_test_003, TestSize.Level1) +{ + DHLOGI("DcameraSourceCallbackProxyTest::dcamera_source_callback_proxy_test_003"); + sptr samgr = + SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); + sptr remoteObject = samgr->GetSystemAbility(DISTRIBUTED_HARDWARE_CAMERA_SOURCE_SA_ID); + sptr callbackProxy(new DCameraSourceCallbackProxy(remoteObject)); + EXPECT_EQ(false, callbackProxy == nullptr); + + int32_t status = 0; + int32_t ret = callbackProxy->OnNotifyRegResult(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, TEST_REQID, status, TEST_ATTRS); + EXPECT_EQ(DCAMERA_OK, status); + + ret = callbackProxy->OnNotifyUnregResult(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, TEST_REQID, status, TEST_ATTRS); + EXPECT_EQ(DCAMERA_OK, status); +} +} // namespace DistributedHardware +} // namespace OHOS \ No newline at end of file diff --git a/services/cameraservice/sourceservice/test/unittest/common/distributedcamera/dcamera_source_hidumper_test.cpp b/services/cameraservice/sourceservice/test/unittest/common/distributedcamera/dcamera_source_hidumper_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..ce9ce260a19e42aa3eb194ac0f4f9b49bb26e1fc --- /dev/null +++ b/services/cameraservice/sourceservice/test/unittest/common/distributedcamera/dcamera_source_hidumper_test.cpp @@ -0,0 +1,155 @@ +/* + * 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_source_hidumper.h" +#include "distributed_hardware_log.h" + +using namespace testing::ext; + +namespace OHOS { +namespace DistributedHardware { +class DcameraSourceHidumperTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); +}; + +void DcameraSourceHidumperTest::SetUpTestCase(void) +{ + DHLOGI("DcameraSourceHidumperTest::SetUpTestCase"); +} + +void DcameraSourceHidumperTest::TearDownTestCase(void) +{ + DHLOGI("DcameraSourceHidumperTest::TearDownTestCase"); +} + +void DcameraSourceHidumperTest::SetUp(void) +{ + DHLOGI("DcameraSourceHidumperTest::SetUp"); +} + +void DcameraSourceHidumperTest::TearDown(void) +{ + DHLOGI("DcameraSourceHidumperTest::TearDown"); +} + +/** + * @tc.name: dcamera_source_hidumper_test_001 + * @tc.desc: Verify the Dump function. + * @tc.type: FUNC + * @tc.require: issue + */ +HWTEST_F(DcameraSourceHidumperTest, dcamera_source_hidumper_test_001, TestSize.Level1) +{ + DHLOGI("DcameraSourceHidumperTest::dcamera_source_hidumper_test_001"); + std::vector args; + std::string result; + bool ret = DcameraSourceHidumper::GetInstance().Dump(args, result); + EXPECT_EQ(true, ret); +} + +/** + * @tc.name: dcamera_source_hidumper_test_002 + * @tc.desc: Verify the Dump function. + * @tc.type: FUNC + * @tc.require: issue + */ +HWTEST_F(DcameraSourceHidumperTest, dcamera_source_hidumper_test_002, TestSize.Level1) +{ + DHLOGI("DcameraSourceHidumperTest::dcamera_source_hidumper_test_002"); + std::vector args; + std::string str1 = "--version"; + std::string str2 = "--camNum"; + args.push_back(str1); + args.push_back(str2); + std::string result; + bool ret = DcameraSourceHidumper::GetInstance().Dump(args, result); + EXPECT_EQ(true, ret); +} + +/** + * @tc.name: dcamera_source_hidumper_test_003 + * @tc.desc: Verify the Dump function. + * @tc.type: FUNC + * @tc.require: issue + */ +HWTEST_F(DcameraSourceHidumperTest, dcamera_source_hidumper_test_003, TestSize.Level1) +{ + DHLOGI("DcameraSourceHidumperTest::dcamera_source_hidumper_test_003"); + std::vector args; + std::string str1 = "--version"; + args.push_back(str1); + std::string result; + bool ret = DcameraSourceHidumper::GetInstance().Dump(args, result); + EXPECT_EQ(true, ret); +} + +/** + * @tc.name: dcamera_source_hidumper_test_004 + * @tc.desc: Verify the Dump function. + * @tc.type: FUNC + * @tc.require: issue + */ +HWTEST_F(DcameraSourceHidumperTest, dcamera_source_hidumper_test_004, TestSize.Level1) +{ + DHLOGI("DcameraSourceHidumperTest::dcamera_source_hidumper_test_004"); + std::vector args; + std::string str1 = "--registered"; + args.push_back(str1); + std::string result; + bool ret = DcameraSourceHidumper::GetInstance().Dump(args, result); + EXPECT_EQ(true, ret); +} + +/** + * @tc.name: dcamera_source_hidumper_test_005 + * @tc.desc: Verify the Dump function. + * @tc.type: FUNC + * @tc.require: issue + */ +HWTEST_F(DcameraSourceHidumperTest, dcamera_source_hidumper_test_005, TestSize.Level1) +{ + DHLOGI("DcameraSourceHidumperTest::dcamera_source_hidumper_test_005"); + std::vector args; + std::string str1 = "--curState"; + args.push_back(str1); + std::string result; + bool ret = DcameraSourceHidumper::GetInstance().Dump(args, result); + EXPECT_EQ(true, ret); +} + +/** + * @tc.name: dcamera_source_hidumper_test_006 + * @tc.desc: Verify the Dump function. + * @tc.type: FUNC + * @tc.require: issue + */ +HWTEST_F(DcameraSourceHidumperTest, dcamera_source_hidumper_test_006, TestSize.Level1) +{ + DHLOGI("DcameraSourceHidumperTest::dcamera_source_hidumper_test_006"); + std::vector args; + std::string str1 = "-h"; + args.push_back(str1); + std::string result; + bool ret = DcameraSourceHidumper::GetInstance().Dump(args, result); + EXPECT_EQ(true, ret); +} +} // namespace DistributedHardware +} // namespace OHOS \ No newline at end of file diff --git a/services/cameraservice/sourceservice/test/unittest/common/distributedcamera/distributed_camera_source_service_test.cpp b/services/cameraservice/sourceservice/test/unittest/common/distributedcamera/distributed_camera_source_service_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..f8caae679907d3e244480b7dfe670415179d05f5 --- /dev/null +++ b/services/cameraservice/sourceservice/test/unittest/common/distributedcamera/distributed_camera_source_service_test.cpp @@ -0,0 +1,118 @@ +/* + * 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 "distributed_camera_source_service.h" +#include "distributed_camera_errno.h" +#include "distributed_hardware_log.h" + +using namespace testing::ext; + +namespace OHOS { +namespace DistributedHardware { +class DistributedCameraSourceServiceTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); + + std::shared_ptr testSrcService_; +}; + +namespace { +const std::string TEST_DEVICE_ID = "bb536a637105409e904d4da83790a4a7"; +const std::string TEST_CAMERA_DH_ID_0 = "camera_0"; +const std::string TEST_REQID = "bb536a637105409e904d4da83790a4a7"; +} + +void DistributedCameraSourceServiceTest::SetUpTestCase(void) +{ + DHLOGI("DistributedCameraSourceServiceTest::SetUpTestCase"); +} + +void DistributedCameraSourceServiceTest::TearDownTestCase(void) +{ + DHLOGI("DistributedCameraSourceServiceTest::TearDownTestCase"); +} + +void DistributedCameraSourceServiceTest::SetUp(void) +{ + DHLOGI("DistributedCameraSourceServiceTest::SetUp"); + testSrcService_ = std::make_shared(DISTRIBUTED_HARDWARE_CAMERA_SOURCE_SA_ID, true); +} + +void DistributedCameraSourceServiceTest::TearDown(void) +{ + DHLOGI("DistributedCameraSourceServiceTest::TearDown"); + testSrcService_ = nullptr; +} + +/** + * @tc.name: dcamera_source_service_test_001 + * @tc.desc: Verify the RegisterDistributedHardware UnregisterDistributedHardware function. + * @tc.type: FUNC + * @tc.require: issue + */ +HWTEST_F(DistributedCameraSourceServiceTest, dcamera_source_service_test_001, TestSize.Level1) +{ + DHLOGI("DistributedCameraSourceServiceTest::dcamera_source_service_test_001"); + EXPECT_EQ(false, testSrcService_ == nullptr); + + EnableParam param; + int32_t ret = testSrcService_->RegisterDistributedHardware(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, TEST_REQID, param); + EXPECT_EQ(DCAMERA_OK, ret); + + ret = testSrcService_->UnregisterDistributedHardware(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, TEST_REQID); + EXPECT_EQ(DCAMERA_OK, ret); +} + +/** + * @tc.name: dcamera_source_service_test_002 + * @tc.desc: Verify the DCameraNotify function. + * @tc.type: FUNC + * @tc.require: issue + */ +HWTEST_F(DistributedCameraSourceServiceTest, dcamera_source_service_test_002, TestSize.Level1) +{ + DHLOGI("DistributedCameraSourceServiceTest::dcamera_source_service_test_002"); + EXPECT_EQ(false, testSrcService_ == nullptr); + + std::string events; + int32_t ret = testSrcService_->DCameraNotify(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, events); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); +} + +/** + * @tc.name: dcamera_source_service_test_003 + * @tc.desc: Verify the Dump function. + * @tc.type: FUNC + * @tc.require: issue + */ +HWTEST_F(DistributedCameraSourceServiceTest, dcamera_source_service_test_003, TestSize.Level1) +{ + DHLOGI("DistributedCameraSourceServiceTest::dcamera_source_service_test_003"); + EXPECT_EQ(false, testSrcService_ == nullptr); + + int32_t fd = 0; + std::vector args; + std::u16string str(u""); + args.push_back(str); + int ret = testSrcService_->Dump(fd, args); + EXPECT_EQ(DCAMERA_OK, ret); +} +} // namespace DistributedHardware +} // namespace OHOS \ No newline at end of file diff --git a/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/BUILD.gn b/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/BUILD.gn index ef61a8fbc824bff1609e46a8243c5200d5704178..981b164c2a018c86235968d53e1c727ec5ae75b8 100644 --- a/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/BUILD.gn +++ b/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/BUILD.gn @@ -56,6 +56,8 @@ ohos_unittest("DCameraSourceMgrTest") { module_out_path = module_out_path sources = [ + "dcamera_hdf_operate_test.cpp", + "dcamera_provider_callback_impl_test.cpp", "dcamera_source_controller_test.cpp", "dcamera_source_data_process_test.cpp", "dcamera_source_dev_test.cpp", @@ -90,7 +92,7 @@ ohos_unittest("DCameraSourceMgrTest") { ] } -group("dcamera_mgr_test") { +group("dcamera_source_mgr_test") { testonly = true deps = [ ":DCameraSourceMgrTest" ] } diff --git a/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_hdf_operate_test.cpp b/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_hdf_operate_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..64d3bf710722e5ee7eca13b8ecc3b82c68fe53c8 --- /dev/null +++ b/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_hdf_operate_test.cpp @@ -0,0 +1,80 @@ +/* + * 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_hdf_operate.h" +#include "distributed_camera_errno.h" +#include "distributed_hardware_log.h" + +using namespace testing::ext; + +namespace OHOS { +namespace DistributedHardware { +class DCameraHdfOperateTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); +}; + +void DCameraHdfOperateTest::SetUpTestCase(void) +{ + DHLOGI("DCameraHdfOperateTest::SetUpTestCase"); +} + +void DCameraHdfOperateTest::TearDownTestCase(void) +{ + DHLOGI("DCameraHdfOperateTest::TearDownTestCase"); +} + +void DCameraHdfOperateTest::SetUp(void) +{ + DHLOGI("DCameraHdfOperateTest::SetUp"); +} + +void DCameraHdfOperateTest::TearDown(void) +{ + DHLOGI("DCameraHdfOperateTest::TearDown"); +} + +/** + * @tc.name: dcamera_hdf_operate_test_001 + * @tc.desc: Verify LoadDcameraHDFImpl func. + * @tc.type: FUNC + * @tc.require: issue + */ +HWTEST_F(DCameraHdfOperateTest, dcamera_hdf_operate_test_001, TestSize.Level1) +{ + DHLOGI("DCameraHdfOperateTest::dcamera_hdf_operate_test_001"); + int32_t ret = DCameraHdfOperate::GetInstance().LoadDcameraHDFImpl(); + EXPECT_EQ(DCAMERA_OK, ret); +} + +/** + * @tc.name: dcamera_hdf_operate_test_002 + * @tc.desc: Verify UnLoadDcameraHDFImpl func. + * @tc.type: FUNC + * @tc.require: issue + */ +HWTEST_F(DCameraHdfOperateTest, dcamera_hdf_operate_test_002, TestSize.Level1) +{ + DHLOGI("DCameraHdfOperateTest::dcamera_hdf_operate_test_002"); + int32_t ret = DCameraHdfOperate::GetInstance().UnLoadDcameraHDFImpl(); + EXPECT_EQ(DCAMERA_OK, ret); +} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_provider_callback_impl_test.cpp b/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_provider_callback_impl_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..131b24655692464179636055b4b3b2225bbf99e1 --- /dev/null +++ b/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_provider_callback_impl_test.cpp @@ -0,0 +1,299 @@ +/* + * 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_provider_callback_impl.h" +#include "distributed_camera_constants.h" +#include "distributed_camera_errno.h" +#include "distributed_hardware_log.h" +#include "mock_dcamera_source_dev.h" +#include "mock_dcamera_source_state_listener.h" + +using namespace testing::ext; + +namespace OHOS { +namespace DistributedHardware { +class DCameraProviderCallbackImplTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); + + std::shared_ptr testProviderCallback_; + std::shared_ptr camDev_; + std::shared_ptr stateListener_; + +private: + static void SetStreamInfos(); + static void SetCaptureInfos(); +}; + +namespace { +const std::string TEST_DEVICE_ID = "bb536a637105409e904d4da83790a4a7"; +const std::string TEST_CAMERA_DH_ID_0 = "camera_0"; +const std::string TEST_REQID = "0xFFFF"; +const std::string TEST_PARAM = "0xFFFF"; +const int32_t TEST_WIDTH = 1920; +const int32_t TEST_HEIGTH = 1080; +const int32_t TEST_STREAMID = 2; +const int32_t SLEEP_TIME = 2; +std::vector g_streamInfosSnap; +std::vector g_captureInfoSnap; +std::vector g_cameraSettingSnap; +std::vector g_streamIdSnap; +} + +void DCameraProviderCallbackImplTest::SetUpTestCase(void) +{ + SetStreamInfos(); + SetCaptureInfos(); +} + +void DCameraProviderCallbackImplTest::SetStreamInfos() +{ + DCStreamInfo streamInfo1; + streamInfo1.streamId_ = 1; + streamInfo1.width_ = TEST_WIDTH; + streamInfo1.height_ = TEST_HEIGTH; + streamInfo1.stride_ = 1; + streamInfo1.format_ = 1; + streamInfo1.dataspace_ = 1; + streamInfo1.encodeType_ = ENCODE_TYPE_JPEG; + streamInfo1.type_ = SNAPSHOT_FRAME; + + DCStreamInfo streamInfo2; + streamInfo2.streamId_ = TEST_STREAMID; + streamInfo2.width_ = TEST_WIDTH; + streamInfo2.height_ = TEST_HEIGTH; + streamInfo2.stride_ = 1; + streamInfo2.format_ = 1; + streamInfo2.dataspace_ = 1; + streamInfo2.encodeType_ = ENCODE_TYPE_JPEG; + streamInfo2.type_ = SNAPSHOT_FRAME; + g_streamInfosSnap.push_back(streamInfo1); + g_streamInfosSnap.push_back(streamInfo2); +} + +void DCameraProviderCallbackImplTest::SetCaptureInfos() +{ + DCCaptureInfo captureInfo1; + captureInfo1.streamIds_.push_back(1); + captureInfo1.width_ = TEST_WIDTH; + captureInfo1.height_ = TEST_HEIGTH; + captureInfo1.stride_ = 1; + captureInfo1.format_ = 1; + captureInfo1.dataspace_ = 1; + captureInfo1.encodeType_ = ENCODE_TYPE_H265; + captureInfo1.type_ = CONTINUOUS_FRAME; + + DCCaptureInfo captureInfo2; + captureInfo2.streamIds_.push_back(1); + captureInfo2.width_ = TEST_WIDTH; + captureInfo2.height_ = TEST_HEIGTH; + captureInfo2.stride_ = 1; + captureInfo2.format_ = 1; + captureInfo2.dataspace_ = 1; + captureInfo2.encodeType_ = ENCODE_TYPE_H265; + captureInfo2.type_ = CONTINUOUS_FRAME; + g_captureInfoSnap.push_back(captureInfo1); + g_captureInfoSnap.push_back(captureInfo2); + + DCameraSettings camSettings1; + camSettings1.type_ = UPDATE_METADATA; + camSettings1.value_ = "SettingValue"; + + DCameraSettings camSettings2; + camSettings2.type_ = ENABLE_METADATA; + camSettings2.value_ = "SettingValue"; + g_cameraSettingSnap.push_back(camSettings1); + g_cameraSettingSnap.push_back(camSettings2); + + g_streamIdSnap.push_back(1); + g_streamIdSnap.push_back(TEST_STREAMID); +} + +void DCameraProviderCallbackImplTest::TearDownTestCase(void) +{ +} + +void DCameraProviderCallbackImplTest::SetUp(void) +{ + stateListener_ = std::make_shared(); + camDev_ = std::make_shared(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, stateListener_); + camDev_->InitDCameraSourceDev(); + testProviderCallback_ = std::make_shared(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, camDev_); +} + +void DCameraProviderCallbackImplTest::TearDown(void) +{ + testProviderCallback_ = nullptr; + camDev_ = nullptr; + stateListener_ = nullptr; +} + +/** + * @tc.name: dcamera_provider_callback_impl_test_001 + * @tc.desc: Verify OpenSession CloseSession func. + * @tc.type: FUNC + * @tc.require: issue + */ +HWTEST_F(DCameraProviderCallbackImplTest, dcamera_provider_callback_impl_test_001, TestSize.Level1) +{ + EXPECT_EQ(false, testProviderCallback_ == nullptr); + + DHBase dhBase; + int32_t ret = testProviderCallback_->OpenSession(dhBase); + EXPECT_EQ(FAILED, ret); + + ret = testProviderCallback_->CloseSession(dhBase); + EXPECT_EQ(FAILED, ret); +} + +/** + * @tc.name: dcamera_provider_callback_impl_test_002 + * @tc.desc: Verify OpenSession CloseSession func. + * @tc.type: FUNC + * @tc.require: issue + */ +HWTEST_F(DCameraProviderCallbackImplTest, dcamera_provider_callback_impl_test_002, TestSize.Level1) +{ + EXPECT_EQ(false, testProviderCallback_ == nullptr); + DHBase dhBase{TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0}; + int32_t ret = testProviderCallback_->OpenSession(dhBase); + EXPECT_EQ(SUCCESS, ret); + + ret = testProviderCallback_->CloseSession(dhBase); + EXPECT_EQ(SUCCESS, ret); + sleep(SLEEP_TIME); +} + +/** + * @tc.name: dcamera_provider_callback_impl_test_003 + * @tc.desc: Verify ConfigureStreams ReleaseStreams func. + * @tc.type: FUNC + * @tc.require: issue + */ +HWTEST_F(DCameraProviderCallbackImplTest, dcamera_provider_callback_impl_test_003, TestSize.Level1) +{ + EXPECT_EQ(false, testProviderCallback_ == nullptr); + + DHBase dhBase; + std::vector streamInfos; + int32_t ret = testProviderCallback_->ConfigureStreams(dhBase, streamInfos); + EXPECT_EQ(FAILED, ret); + + std::vector streamIds; + ret = testProviderCallback_->ReleaseStreams(dhBase, streamIds); + EXPECT_EQ(FAILED, ret); +} + +/** + * @tc.name: dcamera_provider_callback_impl_test_004 + * @tc.desc: Verify ConfigureStreams ReleaseStreams func. + * @tc.type: FUNC + * @tc.require: issue + */ +HWTEST_F(DCameraProviderCallbackImplTest, dcamera_provider_callback_impl_test_004, TestSize.Level1) +{ + EXPECT_EQ(false, testProviderCallback_ == nullptr); + + DHBase dhBase{TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0}; + int32_t ret = testProviderCallback_->ConfigureStreams(dhBase, g_streamInfosSnap); + EXPECT_EQ(SUCCESS, ret); + + ret = testProviderCallback_->ReleaseStreams(dhBase, g_streamIdSnap); + EXPECT_EQ(SUCCESS, ret); + sleep(SLEEP_TIME); +} + +/** + * @tc.name: dcamera_provider_callback_impl_test_005 + * @tc.desc: Verify StartCapture StopCapture func. + * @tc.type: FUNC + * @tc.require: issue + */ +HWTEST_F(DCameraProviderCallbackImplTest, dcamera_provider_callback_impl_test_005, TestSize.Level1) +{ + EXPECT_EQ(false, testProviderCallback_ == nullptr); + + DHBase dhBase; + std::vector captureInfos; + int32_t ret = testProviderCallback_->StartCapture(dhBase, g_captureInfoSnap); + EXPECT_EQ(FAILED, ret); + + std::vector streamIds; + ret = testProviderCallback_->StopCapture(dhBase, streamIds); + EXPECT_EQ(FAILED, ret); +} + +/** + * @tc.name: dcamera_provider_callback_impl_test_006 + * @tc.desc: Verify StartCapture StopCapture func. + * @tc.type: FUNC + * @tc.require: issue + */ +HWTEST_F(DCameraProviderCallbackImplTest, dcamera_provider_callback_impl_test_006, TestSize.Level1) +{ + EXPECT_EQ(false, testProviderCallback_ == nullptr); + + DHBase dhBase{TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0}; + int32_t ret = testProviderCallback_->StartCapture(dhBase, g_captureInfoSnap); + EXPECT_EQ(SUCCESS, ret); + + ret = testProviderCallback_->StopCapture(dhBase, g_streamIdSnap); + EXPECT_EQ(SUCCESS, ret); + sleep(SLEEP_TIME); +} + +/** + * @tc.name: dcamera_provider_callback_impl_test_007 + * @tc.desc: Verify UpdateSettings func. + * @tc.type: FUNC + * @tc.require: issue + */ +HWTEST_F(DCameraProviderCallbackImplTest, dcamera_provider_callback_impl_test_007, TestSize.Level1) +{ + EXPECT_EQ(false, testProviderCallback_ == nullptr); + + DHBase dhBase; + int32_t ret = testProviderCallback_->UpdateSettings(dhBase, g_cameraSettingSnap); + EXPECT_EQ(FAILED, ret); +} + +/** + * @tc.name: dcamera_provider_callback_impl_test_008 + * @tc.desc: Verify UpdateSettings func. + * @tc.type: FUNC + * @tc.require: issue + */ +HWTEST_F(DCameraProviderCallbackImplTest, dcamera_provider_callback_impl_test_008, TestSize.Level1) +{ + EXPECT_EQ(false, testProviderCallback_ == nullptr); + + DHBase dhBase{TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0}; + int32_t ret = testProviderCallback_->OpenSession(dhBase); + EXPECT_EQ(SUCCESS, ret); + + ret = testProviderCallback_->UpdateSettings(dhBase, g_cameraSettingSnap); + EXPECT_EQ(SUCCESS, ret); + + ret = testProviderCallback_->CloseSession(dhBase); + EXPECT_EQ(SUCCESS, ret); + sleep(SLEEP_TIME); +} +} // namespace DistributedHardware +} // namespace OHOS