diff --git a/interfaces/inner_kits/test/fuzztest/distributedhardwarefwkkit_fuzzer/distributedhardwarefwkkit_fuzzer.cpp b/interfaces/inner_kits/test/fuzztest/distributedhardwarefwkkit_fuzzer/distributedhardwarefwkkit_fuzzer.cpp index fc0c4608434c81241fe5cdac351a9d86cd580384..1d303ef0caf7b04e34b4e1a43fa813950b824307 100644 --- a/interfaces/inner_kits/test/fuzztest/distributedhardwarefwkkit_fuzzer/distributedhardwarefwkkit_fuzzer.cpp +++ b/interfaces/inner_kits/test/fuzztest/distributedhardwarefwkkit_fuzzer/distributedhardwarefwkkit_fuzzer.cpp @@ -1,5 +1,5 @@ /* - * 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 @@ -40,6 +40,30 @@ void TestPublisherListener::OnMessage(const DHTopic topic, const std::string &me (void)message; } +void TestHDSinkStatusListener::OnEnable(const DHDescriptor &dhDescriptor) +{ + (void)&dhDescriptor; +} + +void TestHDSinkStatusListener::OnDisable(const DHDescriptor &dhDescriptor) +{ + (void)&dhDescriptor; +} + +void TestHDSourceStatusListener::OnEnable( + const std::string &networkId, const DHDescriptor &dhDescriptor) +{ + (void)networkId; + (void)&dhDescriptor; +} + +void TestHDSourceStatusListener::OnDisable( + const std::string &networkId, const DHDescriptor &dhDescriptor) +{ + (void)networkId; + (void)&dhDescriptor; +} + void RegisterPublisherListenerFuzzTest(const uint8_t *data, size_t size) { if ((data == nullptr) || (size < sizeof(uint32_t))) { @@ -169,6 +193,66 @@ void StopDistributedHardwareFuzzTest(const uint8_t *data, size_t size) std::string networkId(reinterpret_cast(data), size); dhfwkKit.StopDistributedHardware(dhType, networkId); } + +void GetDistributedHardwareFuzzTest(const uint8_t *data, size_t size) +{ + if ((data == nullptr) || (size == 0)) { + return; + } + + DistributedHardwareFwkKit dhfwkKit; + std::vector descriptors; + std::string networkId(reinterpret_cast(data), size); + dhfwkKit.GetDistributedHardware(networkId, descriptors); +} + +void RegisterDHStatusListenerFuzzTest(const uint8_t *data, size_t size) +{ + if ((data == nullptr) || (size == 0)) { + return; + } + + DistributedHardwareFwkKit dhfwkKit; + std::string networkId(reinterpret_cast(data), size); + sptr listener(new TestHDSourceStatusListener()); + dhfwkKit.RegisterDHStatusListener(networkId, listener); +} + +void UnregisterDHStatusListenerFuzzTest(const uint8_t *data, size_t size) +{ + if ((data == nullptr) || (size == 0)) { + return; + } + + DistributedHardwareFwkKit dhfwkKit; + std::string networkId(reinterpret_cast(data), size); + sptr listener(new TestHDSourceStatusListener()); + dhfwkKit.UnregisterDHStatusListener(networkId, listener); +} + +void EnableSourceFuzzTest(const uint8_t *data, size_t size) +{ + if ((data == nullptr) || (size == 0)) { + return; + } + + DistributedHardwareFwkKit dhfwkKit; + std::string networkId(reinterpret_cast(data), size); + std::vector descriptors; + dhfwkKit.EnableSource(networkId, descriptors); +} + +void DisableSourceFuzzTest(const uint8_t *data, size_t size) +{ + if ((data == nullptr) || (size == 0)) { + return; + } + + DistributedHardwareFwkKit dhfwkKit; + std::string networkId(reinterpret_cast(data), size); + std::vector descriptors; + dhfwkKit.DisableSource(networkId, descriptors); +} } // namespace DistributedHardware } // namespace OHOS diff --git a/interfaces/inner_kits/test/fuzztest/distributedhardwarefwkkit_fuzzer/distributedhardwarefwkkit_fuzzer.h b/interfaces/inner_kits/test/fuzztest/distributedhardwarefwkkit_fuzzer/distributedhardwarefwkkit_fuzzer.h index d165f8a6eb5d85b2cd0c3fa83b4dee0cbe7265d6..76e62164cec1df2e507ebe6759219e56abfed9c7 100644 --- a/interfaces/inner_kits/test/fuzztest/distributedhardwarefwkkit_fuzzer/distributedhardwarefwkkit_fuzzer.h +++ b/interfaces/inner_kits/test/fuzztest/distributedhardwarefwkkit_fuzzer/distributedhardwarefwkkit_fuzzer.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022 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 @@ -19,6 +19,7 @@ #define FUZZ_PROJECT_NAME "distributedhardwarefwkkit_fuzzer" #include +#include "hardware_status_listener_stub.h" #include "publisher_listener_stub.h" namespace OHOS { @@ -29,6 +30,24 @@ public: virtual ~TestPublisherListener() = default; void OnMessage(const DHTopic topic, const std::string &message); }; + +class TestHDSinkStatusListener : public HDSinkStatusListenerStub { +public: + TestHDSinkStatusListener() = default; + virtual ~TestHDSinkStatusListener() = default; +protected: + void OnEnable(const DHDescriptor &dhDescriptor) override; + void OnDisable(const DHDescriptor &dhDescriptor) override; +}; + +class TestHDSourceStatusListener : public HDSourceStatusListenerStub { +public: + TestHDSourceStatusListener() = default; + virtual ~TestHDSourceStatusListener() = default; +protected: + void OnEnable(const std::string &networkId, const DHDescriptor &dhDescriptor) override; + void OnDisable(const std::string &networkId, const DHDescriptor &dhDescriptor) override; +}; } // namespace DistributedHardware } // namespace OHOS #endif \ No newline at end of file diff --git a/interfaces/inner_kits/test/unittest/BUILD.gn b/interfaces/inner_kits/test/unittest/BUILD.gn index 839dbd1faf0db5eba178a75bc31c523a4ea8a8de..c772c99164f020db811b72578c07a552e6005aaa 100644 --- a/interfaces/inner_kits/test/unittest/BUILD.gn +++ b/interfaces/inner_kits/test/unittest/BUILD.gn @@ -1,4 +1,4 @@ -# Copyright (c) 2022 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 @@ -18,6 +18,7 @@ group("kit_test") { "common/distributedhardwarefwkkit:distributed_hardware_fwk_kit_test", "common/ipc/dhfwk_sa_manager:dhfwk_sa_manager_test", "common/ipc/distributed_hardware_proxy:DistributedHardwareProxyTest", + "common/ipc/hardware_status_listener_stub:HardwareStatusListenerStubTest", "common/ipc/publisher_listener_stub:PublisherListenerStubTest", ] } diff --git a/interfaces/inner_kits/test/unittest/common/distributedhardwarefwkkit/include/distributed_hardware_fwk_kit_test.h b/interfaces/inner_kits/test/unittest/common/distributedhardwarefwkkit/include/distributed_hardware_fwk_kit_test.h index 2ab039f22e2f935fe1b124a1c13fd391ff0403c5..2e6995ec7ed2dfc776641dc9c3eb90fa071f7485 100644 --- a/interfaces/inner_kits/test/unittest/common/distributedhardwarefwkkit/include/distributed_hardware_fwk_kit_test.h +++ b/interfaces/inner_kits/test/unittest/common/distributedhardwarefwkkit/include/distributed_hardware_fwk_kit_test.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022 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 @@ -24,6 +24,7 @@ #include #include "distributed_hardware_fwk_kit.h" +#include "hardware_status_listener_stub.h" #include "publisher_listener_stub.h" #include "system_ability_load_callback_stub.h" @@ -50,6 +51,24 @@ public: std::map msgCnts_ = {}; }; + class TestHDSinkStatusListener : public HDSinkStatusListenerStub { + public: + TestHDSinkStatusListener() = default; + virtual ~TestHDSinkStatusListener() = default; + protected: + void OnEnable(const DHDescriptor &dhDescriptor) override; + void OnDisable(const DHDescriptor &dhDescriptor) override; + }; + + class TestHDSourceStatusListener : public HDSourceStatusListenerStub { + public: + TestHDSourceStatusListener() = default; + virtual ~TestHDSourceStatusListener() = default; + protected: + void OnEnable(const std::string &networkId, const DHDescriptor &dhDescriptor) override; + void OnDisable(const std::string &networkId, const DHDescriptor &dhDescriptor) override; + }; + public: std::shared_ptr dhfwkPtr_ = nullptr; }; diff --git a/interfaces/inner_kits/test/unittest/common/distributedhardwarefwkkit/src/distributed_hardware_fwk_kit_test.cpp b/interfaces/inner_kits/test/unittest/common/distributedhardwarefwkkit/src/distributed_hardware_fwk_kit_test.cpp index ae4eb0bac4a102fd23dce9be24bac527882ea152..c6127739217a3759220b33c8ab9dbbccc83e32e8 100644 --- a/interfaces/inner_kits/test/unittest/common/distributedhardwarefwkkit/src/distributed_hardware_fwk_kit_test.cpp +++ b/interfaces/inner_kits/test/unittest/common/distributedhardwarefwkkit/src/distributed_hardware_fwk_kit_test.cpp @@ -73,6 +73,30 @@ uint32_t DistributedHardwareFwkKitTest::TestPublisherListener::GetTopicMsgCnt(co return msgCnts_[topic]; } +void DistributedHardwareFwkKitTest::TestHDSinkStatusListener::OnEnable(const DHDescriptor &dhDescriptor) +{ + (void)&dhDescriptor; +} + +void DistributedHardwareFwkKitTest::TestHDSinkStatusListener::OnDisable(const DHDescriptor &dhDescriptor) +{ + (void)&dhDescriptor; +} + +void DistributedHardwareFwkKitTest::TestHDSourceStatusListener::OnEnable( + const std::string &networkId, const DHDescriptor &dhDescriptor) +{ + (void)networkId; + (void)&dhDescriptor; +} + +void DistributedHardwareFwkKitTest::TestHDSourceStatusListener::OnDisable( + const std::string &networkId, const DHDescriptor &dhDescriptor) +{ + (void)networkId; + (void)&dhDescriptor; +} + /** * @tc.name: RegisterPublisherListener_001 * @tc.desc: Verify the RegisterPublisherListener function @@ -402,5 +426,156 @@ HWTEST_F(DistributedHardwareFwkKitTest, StopDistributedHardware_001, testing::ex ret = dhfwkPtr_->StopDistributedHardware(dhType, networkId); EXPECT_EQ(ERR_DH_FWK_POINTER_IS_NULL, ret); } + +/** + * @tc.name: GetDistributedHardware_001 + * @tc.desc: Verify the GetDistributedHardware function + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(DistributedHardwareFwkKitTest, GetDistributedHardware_001, testing::ext::TestSize.Level0) +{ + ASSERT_TRUE(dhfwkPtr_ != nullptr); + std::string networkId = ""; + std::vector descriptors; + int32_t ret = dhfwkPtr_->GetDistributedHardware(networkId, descriptors); + EXPECT_EQ(ERR_DH_FWK_PARA_INVALID, ret); + + networkId = "networkId_test"; + ret = dhfwkPtr_->GetDistributedHardware(networkId, descriptors); + EXPECT_EQ(ERR_DH_FWK_POINTER_IS_NULL, ret); +} + +/** + * @tc.name: RegisterDHStatusListener_001 + * @tc.desc: Verify the RegisterDHStatusListener function + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(DistributedHardwareFwkKitTest, RegisterDHStatusListener_001, testing::ext::TestSize.Level0) +{ + ASSERT_TRUE(dhfwkPtr_ != nullptr); + sptr listener(new TestHDSinkStatusListener()); + int32_t ret = dhfwkPtr_->RegisterDHStatusListener(listener); + EXPECT_EQ(ERR_DH_FWK_POINTER_IS_NULL, ret); +} + +/** + * @tc.name: RegisterDHStatusListener_002 + * @tc.desc: Verify the RegisterDHStatusListener function + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(DistributedHardwareFwkKitTest, RegisterDHStatusListener_002, testing::ext::TestSize.Level0) +{ + ASSERT_TRUE(dhfwkPtr_ != nullptr); + std::string networkId = ""; + sptr listener(new TestHDSourceStatusListener()); + int32_t ret = dhfwkPtr_->RegisterDHStatusListener(networkId, listener); + EXPECT_EQ(ERR_DH_FWK_PARA_INVALID, ret); + + networkId = "networkId_test"; + ret = dhfwkPtr_->RegisterDHStatusListener(networkId, listener); + EXPECT_EQ(ERR_DH_FWK_POINTER_IS_NULL, ret); +} + +/** + * @tc.name: UnregisterDHStatusListener_001 + * @tc.desc: Verify the UnregisterDHStatusListener function + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(DistributedHardwareFwkKitTest, UnregisterDHStatusListener_001, testing::ext::TestSize.Level0) +{ + ASSERT_TRUE(dhfwkPtr_ != nullptr); + sptr listener(new TestHDSinkStatusListener()); + int32_t ret = dhfwkPtr_->UnregisterDHStatusListener(listener); + EXPECT_EQ(ERR_DH_FWK_POINTER_IS_NULL, ret); +} + +/** + * @tc.name: UnregisterDHStatusListener_002 + * @tc.desc: Verify the UnregisterDHStatusListener function + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(DistributedHardwareFwkKitTest, UnregisterDHStatusListener_002, testing::ext::TestSize.Level0) +{ + ASSERT_TRUE(dhfwkPtr_ != nullptr); + std::string networkId = ""; + sptr listener(new TestHDSourceStatusListener()); + int32_t ret = dhfwkPtr_->UnregisterDHStatusListener(networkId, listener); + EXPECT_EQ(ERR_DH_FWK_PARA_INVALID, ret); + + networkId = "networkId_test"; + ret = dhfwkPtr_->UnregisterDHStatusListener(networkId, listener); + EXPECT_EQ(ERR_DH_FWK_POINTER_IS_NULL, ret); +} + +/** + * @tc.name: EnableSink_001 + * @tc.desc: Verify the EnableSink function + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(DistributedHardwareFwkKitTest, EnableSink_001, testing::ext::TestSize.Level0) +{ + ASSERT_TRUE(dhfwkPtr_ != nullptr); + std::vector descriptors; + int32_t ret = dhfwkPtr_->EnableSink(descriptors); + EXPECT_EQ(ERR_DH_FWK_POINTER_IS_NULL, ret); +} + +/** + * @tc.name: DisableSink_001 + * @tc.desc: Verify the DisableSink function + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(DistributedHardwareFwkKitTest, DisableSink_001, testing::ext::TestSize.Level0) +{ + ASSERT_TRUE(dhfwkPtr_ != nullptr); + std::vector descriptors; + int32_t ret = dhfwkPtr_->DisableSink(descriptors); + EXPECT_EQ(ERR_DH_FWK_POINTER_IS_NULL, ret); +} + +/** + * @tc.name: EnableSource_001 + * @tc.desc: Verify the EnableSource function + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(DistributedHardwareFwkKitTest, EnableSource_001, testing::ext::TestSize.Level0) +{ + ASSERT_TRUE(dhfwkPtr_ != nullptr); + std::string networkId = ""; + std::vector descriptors; + int32_t ret = dhfwkPtr_->EnableSource(networkId, descriptors); + EXPECT_EQ(ERR_DH_FWK_PARA_INVALID, ret); + + networkId = "networkId_test"; + ret = dhfwkPtr_->EnableSource(networkId, descriptors); + EXPECT_EQ(ERR_DH_FWK_POINTER_IS_NULL, ret); +} + +/** + * @tc.name: DisableSource_001 + * @tc.desc: Verify the DisableSource function + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(DistributedHardwareFwkKitTest, DisableSource_001, testing::ext::TestSize.Level0) +{ + ASSERT_TRUE(dhfwkPtr_ != nullptr); + std::string networkId = ""; + std::vector descriptors; + int32_t ret = dhfwkPtr_->DisableSource(networkId, descriptors); + EXPECT_EQ(ERR_DH_FWK_PARA_INVALID, ret); + + networkId = "networkId_test"; + ret = dhfwkPtr_->DisableSource(networkId, descriptors); + EXPECT_EQ(ERR_DH_FWK_POINTER_IS_NULL, ret); +} } // namespace DistributedHardware } // namespace OHOS \ No newline at end of file diff --git a/interfaces/inner_kits/test/unittest/common/ipc/hardware_status_listener_stub/BUILD.gn b/interfaces/inner_kits/test/unittest/common/ipc/hardware_status_listener_stub/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..4aa332a15c3cfb34ff1b29d3b745acc4ee5ffe58 --- /dev/null +++ b/interfaces/inner_kits/test/unittest/common/ipc/hardware_status_listener_stub/BUILD.gn @@ -0,0 +1,72 @@ +# 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. + +import("//build/test.gni") +import( + "//foundation/distributedhardware/distributed_hardware_fwk/distributedhardwarefwk.gni") + +module_out_path = "distributed_hardware_fwk/hardware_status_listener_stub_test" + +config("module_private_config") { + visibility = [ ":*" ] + include_dirs = [ + "${av_trans_path}/common/include", + "include", + "${utils_path}/include", + "${utils_path}/include/log", + "${common_path}/utils/include", + "${common_path}/log/include", + "${innerkits_path}/include", + "${innerkits_path}/include/ipc", + ] +} + +ohos_unittest("HardwareStatusListenerStubTest") { + module_out_path = module_out_path + + sources = [ "src/hardware_status_listener_stub_test.cpp" ] + + configs = [ ":module_private_config" ] + + deps = [ + "${innerkits_path}:libdhfwk_sdk", + "${services_path}/distributedhardwarefwkservice:distributedhardwarefwksvr", + "${utils_path}:distributedhardwareutils", + ] + + defines = [ + "HI_LOG_ENABLE", + "DH_LOG_TAG=\"HardwareStatusListenerStubTest\"", + "LOG_DOMAIN=0xD004100", + ] + + external_deps = [ + "cJSON:cjson", + "c_utils:utils", + "ipc:ipc_core", + "safwk:system_ability_fwk", + "samgr:samgr_proxy", + ] + + cflags = [ + "-Wall", + "-Werror", + "-g3", + "-Dprivate=public", + ] +} + +group("hardware_status_listener_stub_test") { + testonly = true + deps = [ ":HardwareStatusListenerStubTest" ] +} diff --git a/interfaces/inner_kits/test/unittest/common/ipc/hardware_status_listener_stub/include/hardware_status_listener_stub_test.h b/interfaces/inner_kits/test/unittest/common/ipc/hardware_status_listener_stub/include/hardware_status_listener_stub_test.h new file mode 100644 index 0000000000000000000000000000000000000000..457bbe5c26c69341e1abb34669ecab3144c86aca --- /dev/null +++ b/interfaces/inner_kits/test/unittest/common/ipc/hardware_status_listener_stub/include/hardware_status_listener_stub_test.h @@ -0,0 +1,70 @@ +/* + * 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_HARDWARE_STATUS_LISTENER_STUB_TEST_H +#define OHOS_HARDWARE_STATUS_LISTENER_STUB_TEST_H + +#include +#include +#include + +#include + +#include "distributed_hardware_errno.h" +#include "iremote_stub.h" +#include "idistributed_hardware.h" +#include "hardware_status_listener_stub.h" + +namespace OHOS { +namespace DistributedHardware { +class HardwareStatusListenerStubTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + virtual void SetUp(); + virtual void TearDown(); + + std::shared_ptr sinkListenerStub_ = nullptr; + std::shared_ptr sourceListenerStub_ = nullptr; +}; + +class MockHDSinkStatusListenerStub : public HDSinkStatusListenerStub { +public: + void OnEnable(const DHDescriptor &dhDescriptor) + { + (void)&dhDescriptor; + } + void OnDisable(const DHDescriptor &dhDescriptor) + { + (void)&dhDescriptor; + } +}; + +class MockHDSourceStatusListenerStub : public HDSourceStatusListenerStub { +public: +void OnEnable(const std::string &networkId, const DHDescriptor &dhDescriptor) +{ + (void)networkId; + (void)&dhDescriptor; +} +void OnDisable(const std::string &networkId, const DHDescriptor &dhDescriptor) +{ + (void)networkId; + (void)&dhDescriptor; +} +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_HARDWARE_STATUS_LISTENER_STUB_TEST_H \ No newline at end of file diff --git a/interfaces/inner_kits/test/unittest/common/ipc/hardware_status_listener_stub/src/hardware_status_listener_stub_test.cpp b/interfaces/inner_kits/test/unittest/common/ipc/hardware_status_listener_stub/src/hardware_status_listener_stub_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..4360c73d647367724e3b6264fe09e48b4ab3427a --- /dev/null +++ b/interfaces/inner_kits/test/unittest/common/ipc/hardware_status_listener_stub/src/hardware_status_listener_stub_test.cpp @@ -0,0 +1,156 @@ +/* + * 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. + */ + +#include "hardware_status_listener_stub_test.h" + +using namespace testing::ext; + +namespace OHOS { +namespace DistributedHardware { +void HardwareStatusListenerStubTest::SetUpTestCase() +{ +} + +void HardwareStatusListenerStubTest::TearDownTestCase() +{ +} + +void HardwareStatusListenerStubTest::SetUp() +{ + sinkListenerStub_ = std::make_shared(); + sourceListenerStub_ = std::make_shared(); +} + +void HardwareStatusListenerStubTest::TearDown() +{ + sinkListenerStub_ = nullptr; + sourceListenerStub_ = nullptr; +} + +/** + * @tc.name: OnRemoteRequest_001 + * @tc.desc: Verify the OnRemoteRequest function + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(HardwareStatusListenerStubTest, OnRemoteRequest_001, TestSize.Level0) +{ + ASSERT_TRUE(sinkListenerStub_ != nullptr); + uint32_t code = 0; + MessageParcel data; + MessageParcel reply; + MessageOption option; + EXPECT_EQ(ERR_INVALID_DATA, sinkListenerStub_->OnRemoteRequest(code, data, reply, option)); +} + +/** + * @tc.name: OnRemoteRequest_002 + * @tc.desc: Verify the OnRemoteRequest function + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(HardwareStatusListenerStubTest, OnRemoteRequest_002, TestSize.Level0) +{ + ASSERT_TRUE(sinkListenerStub_ != nullptr); + uint32_t code = static_cast(IHDSinkStatusListener::Message::ON_ENABLE); + MessageParcel data; + MessageParcel reply; + MessageOption option; + data.WriteInterfaceToken(sinkListenerStub_->GetDescriptor()); + data.WriteInt32(1); + data.WriteInt32(static_cast(DHType::AUDIO)); + data.WriteString("id_test"); + EXPECT_EQ(DH_FWK_SUCCESS, sinkListenerStub_->OnRemoteRequest(code, data, reply, option)); +} + +/** + * @tc.name: OnRemoteRequest_002 + * @tc.desc: Verify the OnRemoteRequest function + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(HardwareStatusListenerStubTest, OnRemoteRequest_003, TestSize.Level0) +{ + ASSERT_TRUE(sinkListenerStub_ != nullptr); + uint32_t code = static_cast(IHDSinkStatusListener::Message::ON_DISABLE); + MessageParcel data; + MessageParcel reply; + MessageOption option; + data.WriteInterfaceToken(sinkListenerStub_->GetDescriptor()); + data.WriteInt32(1); + data.WriteInt32(static_cast(DHType::AUDIO)); + data.WriteString("id_test"); + EXPECT_EQ(DH_FWK_SUCCESS, sinkListenerStub_->OnRemoteRequest(code, data, reply, option)); +} + +/** + * @tc.name: OnRemoteRequest_101 + * @tc.desc: Verify the OnRemoteRequest function + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(HardwareStatusListenerStubTest, OnRemoteRequest_101, TestSize.Level0) +{ + ASSERT_TRUE(sourceListenerStub_ != nullptr); + uint32_t code = 0; + MessageParcel data; + MessageParcel reply; + MessageOption option; + EXPECT_EQ(ERR_INVALID_DATA, sourceListenerStub_->OnRemoteRequest(code, data, reply, option)); +} + +/** + * @tc.name: OnRemoteRequest_102 + * @tc.desc: Verify the OnRemoteRequest function + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(HardwareStatusListenerStubTest, OnRemoteRequest_102, TestSize.Level0) +{ + ASSERT_TRUE(sourceListenerStub_ != nullptr); + uint32_t code = static_cast(IHDSinkStatusListener::Message::ON_ENABLE); + MessageParcel data; + MessageParcel reply; + MessageOption option; + data.WriteInterfaceToken(sourceListenerStub_->GetDescriptor()); + data.WriteString("netWorkId_test"); + data.WriteInt32(1); + data.WriteInt32(static_cast(DHType::AUDIO)); + data.WriteString("id_test"); + EXPECT_EQ(DH_FWK_SUCCESS, sourceListenerStub_->OnRemoteRequest(code, data, reply, option)); +} + +/** + * @tc.name: OnRemoteRequest_103 + * @tc.desc: Verify the OnRemoteRequest function + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(HardwareStatusListenerStubTest, OnRemoteRequest_103, TestSize.Level0) +{ + ASSERT_TRUE(sourceListenerStub_ != nullptr); + uint32_t code = static_cast(IHDSinkStatusListener::Message::ON_DISABLE); + MessageParcel data; + MessageParcel reply; + MessageOption option; + data.WriteInterfaceToken(sourceListenerStub_->GetDescriptor()); + data.WriteString("netWorkId_test"); + data.WriteInt32(1); + data.WriteInt32(static_cast(DHType::AUDIO)); + data.WriteString("id_test"); + EXPECT_EQ(DH_FWK_SUCCESS, sourceListenerStub_->OnRemoteRequest(code, data, reply, option)); +} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/services/distributedhardwarefwkservice/test/fuzztest/componentloader_fuzzer/componentloader_fuzzer.cpp b/services/distributedhardwarefwkservice/test/fuzztest/componentloader_fuzzer/componentloader_fuzzer.cpp index 0a9e568b3b96b26d8bafef7d096b3b2c8d3b23df..ba495a48e53330f3ba554b96effa707b57e9b41f 100644 --- a/services/distributedhardwarefwkservice/test/fuzztest/componentloader_fuzzer/componentloader_fuzzer.cpp +++ b/services/distributedhardwarefwkservice/test/fuzztest/componentloader_fuzzer/componentloader_fuzzer.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022 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 @@ -52,6 +52,10 @@ void ComponentManagerFuzzTest(const uint8_t* data, size_t size) ComponentLoader::GetInstance().ReleaseHardwareHandler(dhType); ComponentLoader::GetInstance().ReleaseSource(dhType); ComponentLoader::GetInstance().ReleaseSink(dhType); + + ComponentLoader::GetInstance().GetHardwareHandler(dhType); + ComponentLoader::GetInstance().GetSource(dhType); + ComponentLoader::GetInstance().GetSink(dhType); } } } diff --git a/services/distributedhardwarefwkservice/test/fuzztest/componentmanager_fuzzer/componentmanager_fuzzer.cpp b/services/distributedhardwarefwkservice/test/fuzztest/componentmanager_fuzzer/componentmanager_fuzzer.cpp index 623a5437793f36650d3033bb1e669309fbf2853e..5d00b2a378748ee39b405850ffadea05c4a55ea3 100644 --- a/services/distributedhardwarefwkservice/test/fuzztest/componentmanager_fuzzer/componentmanager_fuzzer.cpp +++ b/services/distributedhardwarefwkservice/test/fuzztest/componentmanager_fuzzer/componentmanager_fuzzer.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022 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 @@ -47,10 +47,31 @@ void ComponentManagerFuzzTest(const uint8_t* data, size_t size) std::string uuid(reinterpret_cast(data), size); std::string dhId(reinterpret_cast(data), size); DHType dhType = dhTypeFuzz[data[0] % DH_TYPE_SIZE]; + bool enableSink = false; + bool enableSource = false; + sptr sinkListener = nullptr; + sptr sourceListener = nullptr; + int32_t callingUid = *(reinterpret_cast(data)); + int32_t callingPid = *(reinterpret_cast(data)); + DHDescriptor dhDescriptor { + .id = std::string(reinterpret_cast(data), size), + .dhType = dhType + }; ComponentManager::GetInstance().Init(); ComponentManager::GetInstance().Enable(networkId, uuid, dhId, dhType); ComponentManager::GetInstance().Disable(networkId, uuid, dhId, dhType); + ComponentManager::GetInstance().CheckDemandStart(uuid, dhType, enableSink, enableSource); + ComponentManager::GetInstance().RegisterDHStatusListener(sinkListener, callingUid, callingPid); + ComponentManager::GetInstance().UnregisterDHStatusListener(sinkListener, callingUid, callingPid); + ComponentManager::GetInstance().RegisterDHStatusListener(networkId, sourceListener, callingUid, callingPid); + ComponentManager::GetInstance().UnregisterDHStatusListener(networkId, sourceListener, callingUid, callingPid); + ComponentManager::GetInstance().EnableSink(dhDescriptor, callingUid, callingPid); + ComponentManager::GetInstance().DisableSink(dhDescriptor, callingUid, callingPid); + ComponentManager::GetInstance().EnableSource(networkId, dhDescriptor, callingUid, callingPid); + ComponentManager::GetInstance().DisableSource(networkId, dhDescriptor, callingUid, callingPid); + ComponentManager::GetInstance().ForceDisableSink(dhDescriptor); + ComponentManager::GetInstance().ForceDisableSource(networkId, dhDescriptor); ComponentManager::GetInstance().UnInit(); } diff --git a/services/distributedhardwarefwkservice/test/fuzztest/distributedfwkservices_fuzzer/distributedfwkservices_fuzzer.cpp b/services/distributedhardwarefwkservice/test/fuzztest/distributedfwkservices_fuzzer/distributedfwkservices_fuzzer.cpp index fc053180c1e44a163c6d577cf6ba001d114fbe3b..c0a7080c67bec71965f867ec3786aa4cf513574d 100644 --- a/services/distributedhardwarefwkservice/test/fuzztest/distributedfwkservices_fuzzer/distributedfwkservices_fuzzer.cpp +++ b/services/distributedhardwarefwkservice/test/fuzztest/distributedfwkservices_fuzzer/distributedfwkservices_fuzzer.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2024 Huawei Device Co., Ltd. + * Copyright (c) 2024-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 @@ -119,6 +119,96 @@ void FwkServicesStopDistributedHardwareFuzzTest(const uint8_t* data, size_t size service.StopDistributedHardware(dhType, networkId); } + +void FwkServicesGetDistributedHardwareFuzzTest(const uint8_t* data, size_t size) +{ + if ((data == nullptr) || (size == 0)) { + return; + } + DistributedHardwareService service(SAID, true); + std::string networkId(reinterpret_cast(data), size); + std::vector descriptors; + + service.GetDistributedHardware(networkId, descriptors); +} + +void FwkServicesRegisterDHStatusListenerFuzzTest(const uint8_t* data, size_t size) +{ + if ((data == nullptr) || (size == 0)) { + return; + } + DistributedHardwareService service(SAID, true); + std::string networkId(reinterpret_cast(data), size); + sptr listener = nullptr; + + service.RegisterDHStatusListener(networkId, listener); +} + +void FwkServicesUnregisterDHStatusListenerFuzzTest(const uint8_t* data, size_t size) +{ + if ((data == nullptr) || (size == 0)) { + return; + } + DistributedHardwareService service(SAID, true); + std::string networkId(reinterpret_cast(data), size); + sptr listener = nullptr; + + service.UnregisterDHStatusListener(networkId, listener); +} + +void FwkServicesEnableSinkFuzzTest(const uint8_t* data, size_t size) +{ + if ((data == nullptr) || (size == 0)) { + return; + } + DistributedHardwareService service(SAID, true); + std::vector descriptors = { + { std::string(reinterpret_cast(data), size), DHType::AUDIO } + }; + + service.EnableSink(descriptors); +} + +void FwkServicesDisableSinkFuzzTest(const uint8_t* data, size_t size) +{ + if ((data == nullptr) || (size == 0)) { + return; + } + DistributedHardwareService service(SAID, true); + std::vector descriptors = { + { std::string(reinterpret_cast(data), size), DHType::AUDIO } + }; + + service.DisableSink(descriptors); +} + +void FwkServicesEnableSourceFuzzTest(const uint8_t* data, size_t size) +{ + if ((data == nullptr) || (size == 0)) { + return; + } + DistributedHardwareService service(SAID, true); + std::string networkId(reinterpret_cast(data), size); + std::vector descriptors = { + { std::string(reinterpret_cast(data), size), DHType::AUDIO } + }; + + service.EnableSource(networkId, descriptors); +} + +void FwkServicesDisableSourceFuzzTest(const uint8_t* data, size_t size) +{ + if ((data == nullptr) || (size == 0)) { + return; + } + DistributedHardwareService service(SAID, true); + std::string networkId(reinterpret_cast(data), size); + std::vector descriptors = { + { std::string(reinterpret_cast(data), size), DHType::AUDIO } + }; + + service.DisableSource(networkId, descriptors); +} } } diff --git a/services/distributedhardwarefwkservice/test/unittest/BUILD.gn b/services/distributedhardwarefwkservice/test/unittest/BUILD.gn index 35a309885b60454cae8e4074435bcbd02fada529..106d2d4f81d7fc6d0c37c17e953848bb0389a7f1 100644 --- a/services/distributedhardwarefwkservice/test/unittest/BUILD.gn +++ b/services/distributedhardwarefwkservice/test/unittest/BUILD.gn @@ -1,4 +1,4 @@ -# Copyright (c) 2021-2024 Huawei Device Co., Ltd. +# Copyright (c) 2021-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 @@ -27,6 +27,7 @@ group("test") { "common/hidumphelper/enabledcompsdump:enabled_comps_dump_test", "common/hidumphelper/hidumphelper:hidump_helper_test", "common/ipc:publisher_listener_proxy_test", + "common/ipc/hardware_status_listener_proxy:hardware_status_listener_proxy_test", "common/localhardwaremanager/localhardwaremanager:local_hardware_manager_test", "common/localhardwaremanager/pluginlistenerimpl:plugin_listener_impl_test", "common/lowlatency/lowlatency:low_latency_test", diff --git a/services/distributedhardwarefwkservice/test/unittest/common/componentloader/src/component_loader_test.cpp b/services/distributedhardwarefwkservice/test/unittest/common/componentloader/src/component_loader_test.cpp index ef6c796bb0fb82d71b4f0ade4b1132fcccbec706..77624fd2f6cee3e32d6f0af154ecd7f3f9daaeff 100644 --- a/services/distributedhardwarefwkservice/test/unittest/common/componentloader/src/component_loader_test.cpp +++ b/services/distributedhardwarefwkservice/test/unittest/common/componentloader/src/component_loader_test.cpp @@ -218,7 +218,7 @@ HWTEST_F(ComponentLoaderTest, ReleaseHardwareHandler_001, TestSize.Level0) comHandler.hardwareHandler = nullptr; ComponentLoader::GetInstance().compHandlerMap_[DHType::AUDIO] = comHandler; ret = ComponentLoader::GetInstance().ReleaseHardwareHandler(DHType::AUDIO); - EXPECT_EQ(ERR_DH_FWK_LOADER_HANDLER_IS_NULL, ret); + EXPECT_EQ(ERR_DH_FWK_LOADER_HANDLER_UNLOAD, ret); ComponentLoader::GetInstance().compHandlerMap_.clear(); } @@ -237,7 +237,7 @@ HWTEST_F(ComponentLoaderTest, ReleaseSource_001, TestSize.Level0) comHandler.sourceHandler = nullptr; ComponentLoader::GetInstance().compHandlerMap_[DHType::AUDIO] = comHandler; ret = ComponentLoader::GetInstance().ReleaseSource(DHType::AUDIO); - EXPECT_EQ(ERR_DH_FWK_LOADER_HANDLER_IS_NULL, ret); + EXPECT_EQ(ERR_DH_FWK_LOADER_SOURCE_UNLOAD, ret); ComponentLoader::GetInstance().compHandlerMap_.clear(); } @@ -256,7 +256,7 @@ HWTEST_F(ComponentLoaderTest, ReleaseSink_001, TestSize.Level0) comHandler.sinkHandler = nullptr; ComponentLoader::GetInstance().compHandlerMap_[DHType::AUDIO] = comHandler; ret = ComponentLoader::GetInstance().ReleaseSink(DHType::AUDIO); - EXPECT_EQ(ERR_DH_FWK_LOADER_HANDLER_IS_NULL, ret); + EXPECT_EQ(ERR_DH_FWK_LOADER_SINK_UNLOAD, ret); ComponentLoader::GetInstance().compHandlerMap_.clear(); } @@ -1053,5 +1053,29 @@ HWTEST_F(ComponentLoaderTest, GetDHTypeBySrcSaId_001, TestSize.Level0) auto ret = ComponentLoader::GetInstance().GetDHTypeBySrcSaId(saId); EXPECT_EQ(ret, DHType::UNKNOWN); } + +HWTEST_F(ComponentLoaderTest, GetSource_004, TestSize.Level0) +{ + auto ret = ComponentLoader::GetInstance().GetSource(DHType::AUDIO); + EXPECT_EQ(ret, ERR_DH_FWK_LOADER_HANDLER_IS_NULL); +} + +HWTEST_F(ComponentLoaderTest, GetSink_004, TestSize.Level0) +{ + auto ret = ComponentLoader::GetInstance().GetSink(DHType::AUDIO); + EXPECT_EQ(ret, ERR_DH_FWK_LOADER_HANDLER_IS_NULL); +} + +HWTEST_F(ComponentLoaderTest, GetHardwareHandler_004, TestSize.Level0) +{ + auto ret = ComponentLoader::GetInstance().GetHardwareHandler(DHType::AUDIO); + EXPECT_EQ(ret, ERR_DH_FWK_LOADER_HANDLER_IS_NULL); +} + +HWTEST_F(ComponentLoaderTest, IsDHTypeSupport_001, TestSize.Level0) +{ + auto ret = ComponentLoader::GetInstance().IsDHTypeSupport(DHType::AUDIO); + EXPECT_EQ(ret, false); +} } // namespace DistributedHardware } // namespace OHOS diff --git a/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/src/component_manager_test.cpp b/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/src/component_manager_test.cpp index d2bc80c658db902e7749b43e44c7ede9db3026bd..032fa243afe9cfd75dfdb77559c05a2e5e69c9b3 100644 --- a/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/src/component_manager_test.cpp +++ b/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_manager/src/component_manager_test.cpp @@ -147,7 +147,7 @@ HWTEST_F(ComponentManagerTest, init_test_002, TestSize.Level0) { ComponentManager::GetInstance().compMonitorPtr_ = nullptr; auto ret = ComponentManager::GetInstance().Init(); - EXPECT_EQ(ERR_DH_FWK_COMPONENT_MONITOR_NULL, ret); + EXPECT_EQ(DH_FWK_SUCCESS, ret); } /** @@ -174,8 +174,9 @@ HWTEST_F(ComponentManagerTest, init_compSource_test_001, TestSize.Level0) { ComponentLoader::GetInstance().Init(); ComponentManager::GetInstance().compSource_.clear(); + ComponentManager::GetInstance().compMonitorPtr_ = nullptr; auto ret = ComponentManager::GetInstance().InitCompSource(DHType::INPUT); - EXPECT_NE(ret, ComponentManager::GetInstance().compSource_.empty()); + EXPECT_EQ(ret, ERR_DH_FWK_COMPONENT_MONITOR_NULL); } /** @@ -189,7 +190,8 @@ HWTEST_F(ComponentManagerTest, init_compSink_test_001, TestSize.Level0) ComponentLoader::GetInstance().Init(); ComponentManager::GetInstance().compSink_.clear(); auto ret = ComponentManager::GetInstance().InitCompSink(DHType::INPUT); - EXPECT_NE(ret, ComponentManager::GetInstance().compSink_.empty()); + EXPECT_EQ(ret, DH_FWK_SUCCESS); + EXPECT_EQ(ComponentManager::GetInstance().compSink_.empty(), false); } /** @@ -411,7 +413,7 @@ HWTEST_F(ComponentManagerTest, WaitForResult_001, TestSize.Level0) HWTEST_F(ComponentManagerTest, InitCompSink_001, TestSize.Level0) { bool ret = ComponentManager::GetInstance().InitCompSink(DHType::AUDIO); - EXPECT_EQ(true, ret); + EXPECT_EQ(DH_FWK_SUCCESS, ret); } /** @@ -1052,5 +1054,113 @@ HWTEST_F(ComponentManagerTest, GetDHSourceInstance_002, TestSize.Level0) EXPECT_EQ(nullptr, dhSourcePtr); ComponentManager::GetInstance().compSource_.clear(); } + +HWTEST_F(ComponentManagerTest, CheckDemandStart_001, TestSize.Level0) +{ + bool enableSink = false; + bool enableSource = false; + auto ret = ComponentManager::GetInstance().CheckDemandStart(UUID_TEST, DHType::AUDIO, enableSink, enableSource); + EXPECT_EQ(ret, ERR_DH_FWK_RESOURCE_DB_ADAPTER_POINTER_NULL); +} + +HWTEST_F(ComponentManagerTest, RegisterDHStatusListener_001, TestSize.Level0) +{ + sptr listener = nullptr; + auto ret = ComponentManager::GetInstance().RegisterDHStatusListener(listener, 0, 0); + EXPECT_EQ(ret, DH_FWK_SUCCESS); +} + +HWTEST_F(ComponentManagerTest, RegisterDHStatusListener_002, TestSize.Level0) +{ + sptr listener = nullptr; + auto ret = ComponentManager::GetInstance().RegisterDHStatusListener(NETWORK_TEST, listener, 0, 0); + EXPECT_EQ(ret, DH_FWK_SUCCESS); +} + +HWTEST_F(ComponentManagerTest, UnregisterDHStatusListener_001, TestSize.Level0) +{ + sptr listener = nullptr; + auto ret = ComponentManager::GetInstance().UnregisterDHStatusListener(listener, 0, 0); + EXPECT_EQ(ret, DH_FWK_SUCCESS); +} + +HWTEST_F(ComponentManagerTest, UnregisterDHStatusListener_002, TestSize.Level0) +{ + sptr listener = nullptr; + auto ret = ComponentManager::GetInstance().UnregisterDHStatusListener(NETWORK_TEST, listener, 0, 0); + EXPECT_EQ(ret, DH_FWK_SUCCESS); +} + +HWTEST_F(ComponentManagerTest, EnableSink_001, TestSize.Level0) +{ + DHDescriptor dhDescriptor { + .id = DH_ID_TEST, + .dhType = DHType::CAMERA + }; + auto ret = ComponentManager::GetInstance().EnableSink(dhDescriptor, 0, 0); + EXPECT_EQ(ret, DH_FWK_SUCCESS); +} + +HWTEST_F(ComponentManagerTest, DisableSink_001, TestSize.Level0) +{ + DHDescriptor dhDescriptor { + .id = DH_ID_TEST, + .dhType = DHType::CAMERA + }; + auto ret = ComponentManager::GetInstance().DisableSink(dhDescriptor, 0, 0); + EXPECT_EQ(ret, DH_FWK_SUCCESS); +} + +HWTEST_F(ComponentManagerTest, EnableSource_001, TestSize.Level0) +{ + DHDescriptor dhDescriptor { + .id = DH_ID_TEST, + .dhType = DHType::CAMERA + }; + auto ret = ComponentManager::GetInstance().EnableSource(NETWORK_TEST, dhDescriptor, 0, 0); + EXPECT_EQ(ret, ERR_DH_FWK_COMPONENT_MONITOR_NULL); +} + +HWTEST_F(ComponentManagerTest, DisableSource_001, TestSize.Level0) +{ + DHDescriptor dhDescriptor { + .id = DH_ID_TEST, + .dhType = DHType::CAMERA + }; + auto ret = ComponentManager::GetInstance().DisableSource(NETWORK_TEST, dhDescriptor, 0, 0); + EXPECT_EQ(ret, ERR_DH_FWK_COMPONENT_REPEAT_CALL); +} + +HWTEST_F(ComponentManagerTest, ForceDisableSink_001, TestSize.Level0) +{ + DHDescriptor dhDescriptor { + .id = DH_ID_TEST, + .dhType = DHType::CAMERA + }; + auto ret = ComponentManager::GetInstance().ForceDisableSink(dhDescriptor); + EXPECT_EQ(ret, ERR_DH_FWK_LOADER_SINK_UNLOAD); +} + +HWTEST_F(ComponentManagerTest, ForceDisableSource_001, TestSize.Level0) +{ + DHDescriptor dhDescriptor { + .id = DH_ID_TEST, + .dhType = DHType::CAMERA + }; + auto ret = ComponentManager::GetInstance().ForceDisableSource(NETWORK_TEST, dhDescriptor); + EXPECT_EQ(ret, ERR_DH_FWK_PARA_INVALID); +} + +HWTEST_F(ComponentManagerTest, UninitCompSource_001, TestSize.Level0) +{ + auto ret = ComponentManager::GetInstance().UninitCompSource(DHType::CAMERA); + EXPECT_EQ(ret, ERR_DH_FWK_COMPONENT_MONITOR_NULL); +} + +HWTEST_F(ComponentManagerTest, UninitCompSink_001, TestSize.Level0) +{ + auto ret = ComponentManager::GetInstance().UninitCompSink(DHType::CAMERA); + EXPECT_EQ(ret, ERR_DH_FWK_LOADER_SINK_UNLOAD); +} } // namespace DistributedHardware } // namespace OHOS diff --git a/services/distributedhardwarefwkservice/test/unittest/common/distributedhardwareservice/src/distributed_hardware_service_test.cpp b/services/distributedhardwarefwkservice/test/unittest/common/distributedhardwareservice/src/distributed_hardware_service_test.cpp index 9667310ea03448fcd17b9bef3fce7983e2c53072..65be7e244af52755f4f83276b0fb3e89005bd2d5 100644 --- a/services/distributedhardwarefwkservice/test/unittest/common/distributedhardwareservice/src/distributed_hardware_service_test.cpp +++ b/services/distributedhardwarefwkservice/test/unittest/common/distributedhardwareservice/src/distributed_hardware_service_test.cpp @@ -244,6 +244,150 @@ HWTEST_F(DistributedHardwareServiceTest, StopDistributedHardware_001, TestSize.L EXPECT_EQ(ret, ERR_DH_FWK_PARA_INVALID); } +/** + * @tc.name: GetDistributedHardware_001 + * @tc.desc: Verify the GetDistributedHardware function + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(DistributedHardwareServiceTest, GetDistributedHardware_001, TestSize.Level0) +{ + DistributedHardwareService service(ASID, true); + std::vector descriptors; + + std::string networkId = "111"; + auto ret = service.GetDistributedHardware(networkId, descriptors); + EXPECT_EQ(ret, DH_FWK_SUCCESS); + + networkId = "local"; + ret = service.GetDistributedHardware(networkId, descriptors); + EXPECT_EQ(ret, DH_FWK_SUCCESS); +} + +/** + * @tc.name: RegisterDHStatusListener_001 + * @tc.desc: Verify the RegisterDHStatusListener function + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(DistributedHardwareServiceTest, RegisterDHStatusListener_001, TestSize.Level0) +{ + DistributedHardwareService service(ASID, true); + sptr listener = nullptr; + + auto ret = service.RegisterDHStatusListener(listener); + EXPECT_EQ(ret, DH_FWK_SUCCESS); +} + +/** + * @tc.name: RegisterDHStatusListener_002 + * @tc.desc: Verify the RegisterDHStatusListener function + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(DistributedHardwareServiceTest, RegisterDHStatusListener_002, TestSize.Level0) +{ + DistributedHardwareService service(ASID, true); + sptr listener = nullptr; + + std::string networkId = "111"; + auto ret = service.RegisterDHStatusListener(networkId, listener); + EXPECT_EQ(ret, DH_FWK_SUCCESS); +} + +/** + * @tc.name: UnregisterDHStatusListener_001 + * @tc.desc: Verify the UnregisterDHStatusListener function + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(DistributedHardwareServiceTest, UnregisterDHStatusListener_001, TestSize.Level0) +{ + DistributedHardwareService service(ASID, true); + sptr listener = nullptr; + + auto ret = service.UnregisterDHStatusListener(listener); + EXPECT_EQ(ret, DH_FWK_SUCCESS); +} + +/** + * @tc.name: UnregisterDHStatusListener_002 + * @tc.desc: Verify the UnregisterDHStatusListener function + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(DistributedHardwareServiceTest, UnregisterDHStatusListener_002, TestSize.Level0) +{ + DistributedHardwareService service(ASID, true); + sptr listener = nullptr; + + std::string networkId = "111"; + auto ret = service.UnregisterDHStatusListener(networkId, listener); + EXPECT_EQ(ret, DH_FWK_SUCCESS); +} + +/** + * @tc.name: EnableSink_001 + * @tc.desc: Verify the EnableSink function + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(DistributedHardwareServiceTest, EnableSink_001, TestSize.Level0) +{ + DistributedHardwareService service(ASID, true); + std::vector descriptors{{"id_test", DHType::AUDIO}}; + + auto ret = service.EnableSink(descriptors); + EXPECT_EQ(ret, DH_FWK_SUCCESS); +} + +/** + * @tc.name: DisableSink_001 + * @tc.desc: Verify the DisableSink function + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(DistributedHardwareServiceTest, DisableSink_001, TestSize.Level0) +{ + DistributedHardwareService service(ASID, true); + std::vector descriptors{{"id_test", DHType::AUDIO}}; + + auto ret = service.DisableSink(descriptors); + EXPECT_EQ(ret, DH_FWK_SUCCESS); +} + +/** + * @tc.name: EnableSource_001 + * @tc.desc: Verify the EnableSource function + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(DistributedHardwareServiceTest, EnableSource_001, TestSize.Level0) +{ + DistributedHardwareService service(ASID, true); + std::string networkId = "111"; + std::vector descriptors{{"id_test", DHType::AUDIO}}; + + auto ret = service.EnableSource(networkId, descriptors); + EXPECT_EQ(ret, DH_FWK_SUCCESS); +} + +/** + * @tc.name: DisableSource_001 + * @tc.desc: Verify the DisableSource function + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(DistributedHardwareServiceTest, DisableSource_001, TestSize.Level0) +{ + DistributedHardwareService service(ASID, true); + std::string networkId = "111"; + std::vector descriptors{{"id_test", DHType::AUDIO}}; + + auto ret = service.DisableSource(networkId, descriptors); + EXPECT_EQ(ret, DH_FWK_SUCCESS); +} + HWTEST_F(DistributedHardwareServiceTest, ResumeDistributedHardware_002, TestSize.Level0) { DistributedHardwareService service(ASID, true); diff --git a/services/distributedhardwarefwkservice/test/unittest/common/distributedhardwarestub/src/distributed_hardware_stub_test.cpp b/services/distributedhardwarefwkservice/test/unittest/common/distributedhardwarestub/src/distributed_hardware_stub_test.cpp index 9be7aaf192864bbde16e0d834e83b20dfe3017de..475b3b7146967e997670cd2a91a7ceca161a1c2b 100644 --- a/services/distributedhardwarefwkservice/test/unittest/common/distributedhardwarestub/src/distributed_hardware_stub_test.cpp +++ b/services/distributedhardwarefwkservice/test/unittest/common/distributedhardwarestub/src/distributed_hardware_stub_test.cpp @@ -251,6 +251,127 @@ HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_015, TestSize.Level0) EXPECT_EQ(ERR_DH_FWK_ACCESS_PERMISSION_CHECK_FAIL, ret); } +HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_016, TestSize.Level0) +{ + ASSERT_TRUE(stubTest_ != nullptr); + uint32_t code = static_cast(DHMsgInterfaceCode::GET_DISTRIBUTED_HARDWARE); + MessageParcel data; + MessageParcel reply; + MessageOption option; + data.WriteInterfaceToken(stubTest_->GetDescriptor()); + data.WriteString("netWorkId_test"); + auto ret = stubTest_->OnRemoteRequest(code, data, reply, option); + EXPECT_EQ(ERR_DH_FWK_ACCESS_PERMISSION_CHECK_FAIL, ret); +} + +HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_017, TestSize.Level0) +{ + ASSERT_TRUE(stubTest_ != nullptr); + uint32_t code = static_cast(DHMsgInterfaceCode::REG_DH_SINK_STATUS_LISTNER); + MessageParcel data; + MessageParcel reply; + MessageOption option; + data.WriteInterfaceToken(stubTest_->GetDescriptor()); + auto ret = stubTest_->OnRemoteRequest(code, data, reply, option); + EXPECT_EQ(ERR_DH_FWK_ACCESS_PERMISSION_CHECK_FAIL, ret); +} + +HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_018, TestSize.Level0) +{ + ASSERT_TRUE(stubTest_ != nullptr); + uint32_t code = static_cast(DHMsgInterfaceCode::UNREG_DH_SINK_STATUS_LISTNER); + MessageParcel data; + MessageParcel reply; + MessageOption option; + data.WriteInterfaceToken(stubTest_->GetDescriptor()); + auto ret = stubTest_->OnRemoteRequest(code, data, reply, option); + EXPECT_EQ(ERR_DH_FWK_ACCESS_PERMISSION_CHECK_FAIL, ret); +} + +HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_019, TestSize.Level0) +{ + ASSERT_TRUE(stubTest_ != nullptr); + uint32_t code = static_cast(DHMsgInterfaceCode::REG_DH_SOURCE_STATUS_LISTNER); + MessageParcel data; + MessageParcel reply; + MessageOption option; + data.WriteInterfaceToken(stubTest_->GetDescriptor()); + auto ret = stubTest_->OnRemoteRequest(code, data, reply, option); + EXPECT_EQ(ERR_DH_FWK_ACCESS_PERMISSION_CHECK_FAIL, ret); +} + +HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_020, TestSize.Level0) +{ + ASSERT_TRUE(stubTest_ != nullptr); + uint32_t code = static_cast(DHMsgInterfaceCode::UNREG_DH_SOURCE_STATUS_LISTNER); + MessageParcel data; + MessageParcel reply; + MessageOption option; + data.WriteInterfaceToken(stubTest_->GetDescriptor()); + auto ret = stubTest_->OnRemoteRequest(code, data, reply, option); + EXPECT_EQ(ERR_DH_FWK_ACCESS_PERMISSION_CHECK_FAIL, ret); +} + +HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_021, TestSize.Level0) +{ + ASSERT_TRUE(stubTest_ != nullptr); + uint32_t code = static_cast(DHMsgInterfaceCode::ENABLE_SINK); + MessageParcel data; + MessageParcel reply; + MessageOption option; + data.WriteInterfaceToken(stubTest_->GetDescriptor()); + data.WriteInt32(1); + data.WriteInt32(static_cast(DHType::AUDIO)); + data.WriteString("id_test"); + auto ret = stubTest_->OnRemoteRequest(code, data, reply, option); + EXPECT_EQ(ERR_DH_FWK_ACCESS_PERMISSION_CHECK_FAIL, ret); +} + +HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_022, TestSize.Level0) +{ + ASSERT_TRUE(stubTest_ != nullptr); + uint32_t code = static_cast(DHMsgInterfaceCode::DISABLE_SINK); + MessageParcel data; + MessageParcel reply; + MessageOption option; + data.WriteInterfaceToken(stubTest_->GetDescriptor()); + data.WriteInt32(1); + data.WriteInt32(static_cast(DHType::AUDIO)); + data.WriteString("id_test"); + auto ret = stubTest_->OnRemoteRequest(code, data, reply, option); + EXPECT_EQ(ERR_DH_FWK_ACCESS_PERMISSION_CHECK_FAIL, ret); +} + +HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_023, TestSize.Level0) +{ + ASSERT_TRUE(stubTest_ != nullptr); + uint32_t code = static_cast(DHMsgInterfaceCode::ENABLE_SOURCE); + MessageParcel data; + MessageParcel reply; + MessageOption option; + data.WriteInterfaceToken(stubTest_->GetDescriptor()); + data.WriteInt32(1); + data.WriteInt32(static_cast(DHType::AUDIO)); + data.WriteString("id_test"); + auto ret = stubTest_->OnRemoteRequest(code, data, reply, option); + EXPECT_EQ(ERR_DH_FWK_ACCESS_PERMISSION_CHECK_FAIL, ret); +} + +HWTEST_F(DistributedHardwareStubTest, OnRemoteRequest_024, TestSize.Level0) +{ + ASSERT_TRUE(stubTest_ != nullptr); + uint32_t code = static_cast(DHMsgInterfaceCode::DISABLE_SOURCE); + MessageParcel data; + MessageParcel reply; + MessageOption option; + data.WriteInterfaceToken(stubTest_->GetDescriptor()); + data.WriteInt32(1); + data.WriteInt32(static_cast(DHType::AUDIO)); + data.WriteString("id_test"); + auto ret = stubTest_->OnRemoteRequest(code, data, reply, option); + EXPECT_EQ(ERR_DH_FWK_ACCESS_PERMISSION_CHECK_FAIL, ret); +} + /** * @tc.name: RegisterPublisherListenerInner_001 * @tc.desc: Verify the RegisterPublisherListenerInner function diff --git a/services/distributedhardwarefwkservice/test/unittest/common/ipc/hardware_status_listener_proxy/BUILD.gn b/services/distributedhardwarefwkservice/test/unittest/common/ipc/hardware_status_listener_proxy/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..057b92415f18a624ef80541c7bec428596626c34 --- /dev/null +++ b/services/distributedhardwarefwkservice/test/unittest/common/ipc/hardware_status_listener_proxy/BUILD.gn @@ -0,0 +1,63 @@ +# 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. + +import("//build/test.gni") +import( + "//foundation/distributedhardware/distributed_hardware_fwk/distributedhardwarefwk.gni") + +module_out_path = "distributed_hardware_fwk/hardware_status_listener_proxy_test" + +config("module_private_config") { + visibility = [ ":*" ] + include_dirs = [ + "include", + "${common_path}/utils/include", + "${services_path}/distributedhardwarefwkservice/include/ipc", + ] +} + +ohos_unittest("HardwareStatusListenerProxyTest") { + module_out_path = module_out_path + + sources = [ "src/hardware_status_listener_proxy_test.cpp" ] + + configs = [ ":module_private_config" ] + + deps = [ + "${innerkits_path}:libdhfwk_sdk", + "${services_path}/distributedhardwarefwkservice:distributedhardwarefwksvr", + ] + + cflags = [ + "-Wall", + "-Werror", + "-g3", + "-Dprivate=public", + ] + + defines = [ + "HI_LOG_ENABLE", + "DH_LOG_TAG=\"HardwareStatusListenerProxyTest\"", + "LOG_DOMAIN=0xD004100", + ] + + external_deps = [ + "c_utils:utils", + "ipc:ipc_core", + ] +} + +group("hardware_status_listener_proxy_test") { + testonly = true + deps = [ ":HardwareStatusListenerProxyTest" ] +} diff --git a/services/distributedhardwarefwkservice/test/unittest/common/ipc/hardware_status_listener_proxy/include/hardware_status_listener_proxy_test.h b/services/distributedhardwarefwkservice/test/unittest/common/ipc/hardware_status_listener_proxy/include/hardware_status_listener_proxy_test.h new file mode 100644 index 0000000000000000000000000000000000000000..8fddb6cd987530e06c65bccce32e125c7617ee62 --- /dev/null +++ b/services/distributedhardwarefwkservice/test/unittest/common/ipc/hardware_status_listener_proxy/include/hardware_status_listener_proxy_test.h @@ -0,0 +1,56 @@ +/* + * 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_HARDWARE_STATUS_LISTENER_PROXY_TEST_H +#define OHOS_HARDWARE_STATUS_LISTENER_PROXY_TEST_H + +#include +#include +#include + +#include "distributed_hardware_errno.h" +#include "hardware_status_listener_proxy.h" +#include "hardware_status_listener_stub.h" + +namespace OHOS { +namespace DistributedHardware { +class HardwareStatusListenerProxyTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + void SetUp(); + void TearDown(); + + class TestHDSinkStatusListenerStub : public + OHOS::DistributedHardware::HDSinkStatusListenerStub { + public: + TestHDSinkStatusListenerStub() = default; + virtual ~TestHDSinkStatusListenerStub() = default; + void OnEnable(const DHDescriptor &dhDescriptor) override; + void OnDisable(const DHDescriptor &dhDescriptor) override; + }; + + class TestHDSourceStatusListenerStub : public + OHOS::DistributedHardware::HDSourceStatusListenerStub { + public: + TestHDSourceStatusListenerStub() = default; + virtual ~TestHDSourceStatusListenerStub() = default; + void OnEnable(const std::string &networkId, const DHDescriptor &dhDescriptor) override; + void OnDisable(const std::string &networkId, const DHDescriptor &dhDescriptor) override; + }; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_HARDWARE_STATUS_LISTENER_PROXY_TEST_H \ No newline at end of file diff --git a/services/distributedhardwarefwkservice/test/unittest/common/ipc/hardware_status_listener_proxy/src/hardware_status_listener_proxy_test.cpp b/services/distributedhardwarefwkservice/test/unittest/common/ipc/hardware_status_listener_proxy/src/hardware_status_listener_proxy_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..e34dea58d161ac63b4f8f72bb1676f96b13aa1df --- /dev/null +++ b/services/distributedhardwarefwkservice/test/unittest/common/ipc/hardware_status_listener_proxy/src/hardware_status_listener_proxy_test.cpp @@ -0,0 +1,134 @@ +/* + * 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. + */ + +#include "hardware_status_listener_proxy_test.h" + +using namespace testing::ext; + +namespace OHOS { +namespace DistributedHardware { +void HardwareStatusListenerProxyTest::SetUpTestCase() +{ +} + +void HardwareStatusListenerProxyTest::TearDownTestCase() +{ +} + +void HardwareStatusListenerProxyTest::SetUp() +{ +} + +void HardwareStatusListenerProxyTest::TearDown() +{ +} + +void HardwareStatusListenerProxyTest::TestHDSinkStatusListenerStub::OnEnable(const DHDescriptor &dhDescriptor) +{ + (void)dhDescriptor.dhType; +} + +void HardwareStatusListenerProxyTest::TestHDSinkStatusListenerStub::OnDisable(const DHDescriptor &dhDescriptor) +{ + (void)dhDescriptor.dhType; +} + +void HardwareStatusListenerProxyTest::TestHDSourceStatusListenerStub::OnEnable(const std::string &networkId, + const DHDescriptor &dhDescriptor) +{ + (void)networkId; + (void)dhDescriptor.dhType; +} + +void HardwareStatusListenerProxyTest::TestHDSourceStatusListenerStub::OnDisable(const std::string &networkId, + const DHDescriptor &dhDescriptor) +{ + (void)networkId; + (void)dhDescriptor.dhType; +} + +/** + * @tc.name: OnMessage_001 + * @tc.desc: Verify the OnMessage function + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(HardwareStatusListenerProxyTest, OnMessage_001, TestSize.Level0) +{ + DHDescriptor dhDescriptor { + .id = "id_test", + .dhType = DHType::CAMERA + }; + sptr listenerStub(new TestHDSinkStatusListenerStub()); + ASSERT_TRUE(listenerStub != nullptr); + HDSinkStatusListenerProxy listenerProxy(listenerStub); + EXPECT_NO_FATAL_FAILURE(listenerProxy.OnEnable(dhDescriptor)); +} + +/** + * @tc.name: OnMessage_002 + * @tc.desc: Verify the OnMessage function + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(HardwareStatusListenerProxyTest, OnMessage_002, TestSize.Level0) +{ + DHDescriptor dhDescriptor { + .id = "id_test", + .dhType = DHType::CAMERA + }; + sptr listenerStub(new TestHDSinkStatusListenerStub()); + ASSERT_TRUE(listenerStub != nullptr); + HDSinkStatusListenerProxy listenerProxy(listenerStub); + EXPECT_NO_FATAL_FAILURE(listenerProxy.OnDisable(dhDescriptor)); +} + +/** + * @tc.name: OnMessage_101 + * @tc.desc: Verify the OnMessage function + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(HardwareStatusListenerProxyTest, OnMessage_101, TestSize.Level0) +{ + DHDescriptor dhDescriptor { + .id = "id_test", + .dhType = DHType::CAMERA + }; + sptr listenerStub(new TestHDSourceStatusListenerStub()); + ASSERT_TRUE(listenerStub != nullptr); + HDSourceStatusListenerProxy listenerProxy(listenerStub); + EXPECT_NO_FATAL_FAILURE(listenerProxy.OnEnable("netWorkId_test", dhDescriptor)); +} + +/** + * @tc.name: OnMessage_102 + * @tc.desc: Verify the OnMessage function + * @tc.type: FUNC + * @tc.require: AR000GHSJM + */ +HWTEST_F(HardwareStatusListenerProxyTest, OnMessage_102, TestSize.Level0) +{ + DHDescriptor dhDescriptor { + .id = "id_test", + .dhType = DHType::CAMERA + }; + sptr listenerStub(new TestHDSourceStatusListenerStub()); + ASSERT_TRUE(listenerStub != nullptr); + HDSourceStatusListenerProxy listenerProxy(listenerStub); + EXPECT_NO_FATAL_FAILURE(listenerProxy.OnDisable("netWorkId_test", dhDescriptor)); +} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/services/distributedhardwarefwkservice/test/unittest/common/resourcemanager/version_info_test.cpp b/services/distributedhardwarefwkservice/test/unittest/common/resourcemanager/version_info_test.cpp index 8482690ed779abe909b359bfc5c489ab729e44c3..35c65e1745032dc37691b9b25a49d991413b39d5 100644 --- a/services/distributedhardwarefwkservice/test/unittest/common/resourcemanager/version_info_test.cpp +++ b/services/distributedhardwarefwkservice/test/unittest/common/resourcemanager/version_info_test.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2024 Huawei Device Co., Ltd. + * Copyright (c) 2024-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 @@ -58,6 +58,29 @@ HWTEST_F(VersionInfoTest, ToJson_001, TestSize.Level0) EXPECT_TRUE(verInfo.deviceId.empty()); } +HWTEST_F(VersionInfoTest, ToJson_002, TestSize.Level0) +{ + CompVersion compVerTo; + CompVersion compVerFrom; + compVerFrom.name = "name_test"; + compVerFrom.dhType = DHType::AUDIO; + compVerFrom.handlerVersion = "handler_ver_1.0"; + compVerFrom.sourceVersion = "source_ver_1.0"; + compVerFrom.sinkVersion = "sink_ver_1.0"; + compVerFrom.haveFeature = true; + compVerFrom.sourceFeatureFilters = { "feature0", "feature1"}; + compVerFrom.sinkSupportedFeatures = { "feature0", "feature1"}; + cJSON *jsonObj = cJSON_CreateObject(); + ToJson(jsonObj, compVerFrom); + FromJson(jsonObj, compVerTo); + cJSON_Delete(jsonObj); + EXPECT_EQ(compVerTo.name, compVerFrom.name); + EXPECT_EQ(compVerTo.dhType, compVerFrom.dhType); + EXPECT_EQ(compVerTo.haveFeature, compVerFrom.haveFeature); + EXPECT_EQ(compVerTo.sourceFeatureFilters, compVerFrom.sourceFeatureFilters); + EXPECT_EQ(compVerTo.sinkSupportedFeatures, compVerFrom.sinkSupportedFeatures); +} + HWTEST_F(VersionInfoTest, FromJson_CompVersion_001, TestSize.Level0) { cJSON *jsonObj = nullptr;