diff --git a/services/distributedhardwarefwkservice/test/unittest/BUILD.gn b/services/distributedhardwarefwkservice/test/unittest/BUILD.gn index 106d2d4f81d7fc6d0c37c17e953848bb0389a7f1..d179b82b3c40544f6b502336aab584691e931efa 100644 --- a/services/distributedhardwarefwkservice/test/unittest/BUILD.gn +++ b/services/distributedhardwarefwkservice/test/unittest/BUILD.gn @@ -17,6 +17,7 @@ group("test") { deps = [ "common/accessmanager:AccessManagerTest", "common/componentloader:component_loader_test", + "common/componentmanager/component_enable:component_enable_test", "common/componentmanager/component_manager:component_manager_test", "common/componentmanager/component_monitior:component_monitor_test", "common/componentmanager/component_privacy:component_privacy_test", diff --git a/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_enable/BUILD.gn b/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_enable/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..08ae7df9eb2103fa617262c17be7869bdaddf3b2 --- /dev/null +++ b/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_enable/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("../../../../../../../distributedhardwarefwk.gni") + +module_out_path = unittest_output_path + +config("module_private_config") { + visibility = [ ":*" ] + include_dirs = [ + "${utils_path}/include", + "${services_path}/distributedhardwarefwkservice/include", + "${services_path}/distributedhardwarefwkservice/include/componentmanager", + "${services_path}/distributedhardwarefwkservice/include/utils", + "${common_path}/utils/include", + "${common_path}/log/include", + ] +} + +ohos_unittest("ComponentEnableTest") { + module_out_path = module_out_path + + sources = [ + "component_disable_test.cpp", + "component_enable_test.cpp", + ] + + configs = [ ":module_private_config" ] + + deps = [ + "${services_path}/distributedhardwarefwkservice:distributedhardwarefwksvr", + ] + + external_deps = [ + "ability_runtime:ability_manager", + "cJSON:cjson", + "c_utils:utils", + "eventhandler:libeventhandler", + "ipc:ipc_core", + "ipc:ipc_single", + "samgr:samgr_proxy", + ] + + cflags = [ + "-Wall", + "-Werror", + "-g3", + "-Dprivate=public", + ] + + defines = [ + "HI_LOG_ENABLE", + "DH_LOG_TAG=\"ComponentEnableTest\"", + "LOG_DOMAIN=0xD004100", + ] +} + +group("component_enable_test") { + testonly = true + deps = [ ":ComponentEnableTest" ] +} diff --git a/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_enable/component_disable_test.cpp b/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_enable/component_disable_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..1c8e01a0e95c30c6c4829597012e9238c5744b68 --- /dev/null +++ b/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_enable/component_disable_test.cpp @@ -0,0 +1,121 @@ +/* + * 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 "component_disable.h" + +#include +#include + +#include "anonymous_string.h" +#include "constants.h" +#include "dh_utils_tool.h" +#include "distributed_hardware_errno.h" +#include "distributed_hardware_log.h" +#include "idistributed_hardware_source.h" + +using namespace testing::ext; +namespace OHOS { +namespace DistributedHardware { +using namespace std; +constexpr int32_t ENABLE_RESULT_FAILED = -1; +class ComponentDisableTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + void SetUp(); + void TearDown(); +}; + +void ComponentDisableTest::SetUpTestCase() +{ +} + +void ComponentDisableTest::TearDownTestCase() +{ +} + +void ComponentDisableTest::SetUp() +{ +} + +void ComponentDisableTest::TearDown() +{ +} + +HWTEST_F(ComponentDisableTest, Disable_001, testing::ext::TestSize.Level1) +{ + auto compdisable = std::make_shared(); + std::string networkId = ""; + std::string dhId = ""; + IDistributedHardwareSource *sourcePtr = nullptr; + auto ret = compdisable->Disable(networkId, dhId, sourcePtr); + EXPECT_EQ(ret, ERR_DH_FWK_PARA_INVALID); + + networkId = "networkId_test"; + ret = compdisable->Disable(networkId, dhId, sourcePtr); + EXPECT_EQ(ret, ERR_DH_FWK_PARA_INVALID); + + networkId = ""; + dhId = "dhId_test"; + ret = compdisable->Disable(networkId, dhId, sourcePtr); + EXPECT_EQ(ret, ERR_DH_FWK_PARA_INVALID); +} + +HWTEST_F(ComponentDisableTest, Disable_002, testing::ext::TestSize.Level1) +{ + auto compdisable = std::make_shared(); + std::string networkId = "networkId_test"; + std::string dhId = "dhId_test"; + IDistributedHardwareSource *sourcePtr = nullptr; + auto ret = compdisable->Disable(networkId, dhId, sourcePtr); + EXPECT_EQ(ret, ERR_DH_FWK_PARA_INVALID); +} + +HWTEST_F(ComponentDisableTest, OnUnregisterResult_001, testing::ext::TestSize.Level1) +{ + auto compdisable = std::make_shared(); + std::string networkId = ""; + std::string dhId = ""; + int32_t status = 0; + std::string data; + auto ret = compdisable->OnUnregisterResult(networkId, dhId, status, data); + EXPECT_EQ(ret, ERR_DH_FWK_PARA_INVALID); + + networkId = "networkId_test"; + ret = compdisable->OnUnregisterResult(networkId, dhId, status, data); + EXPECT_EQ(ret, ERR_DH_FWK_PARA_INVALID); + + networkId = ""; + dhId = "dhId_test"; + ret = compdisable->OnUnregisterResult(networkId, dhId, status, data); + EXPECT_EQ(ret, ERR_DH_FWK_PARA_INVALID); +} + +HWTEST_F(ComponentDisableTest, OnUnregisterResult_002, testing::ext::TestSize.Level1) +{ + auto compdisable = std::make_shared(); + std::string networkId = "networkId_test"; + std::string dhId = "dhId_test"; + int32_t status = 0; + std::string data; + auto ret = compdisable->OnUnregisterResult(networkId, dhId, status, data); + EXPECT_EQ(ret, DH_FWK_SUCCESS); + + status = ENABLE_RESULT_FAILED; + ret = compdisable->OnUnregisterResult(networkId, dhId, status, data); + EXPECT_EQ(ret, ENABLE_RESULT_FAILED); +} +} +} \ No newline at end of file diff --git a/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_enable/component_enable_test.cpp b/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_enable/component_enable_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..2c5f9c489967fb86ec88604b7d963f1aca929ec4 --- /dev/null +++ b/services/distributedhardwarefwkservice/test/unittest/common/componentmanager/component_enable/component_enable_test.cpp @@ -0,0 +1,123 @@ +/* + * 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 "component_enable.h" + +#include +#include + +#include "anonymous_string.h" +#include "constants.h" +#include "dh_utils_tool.h" +#include "distributed_hardware_errno.h" +#include "distributed_hardware_log.h" +#include "idistributed_hardware_source.h" + +using namespace testing::ext; +namespace OHOS { +namespace DistributedHardware { +using namespace std; +constexpr int32_t ENABLE_RESULT_FAILED = -1; +class ComponentEnableTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + void SetUp(); + void TearDown(); +}; + +void ComponentEnableTest::SetUpTestCase() +{ +} + +void ComponentEnableTest::TearDownTestCase() +{ +} + +void ComponentEnableTest::SetUp() +{ +} + +void ComponentEnableTest::TearDown() +{ +} + +HWTEST_F(ComponentEnableTest, Enable_001, testing::ext::TestSize.Level1) +{ + auto compEnable = std::make_shared(); + std::string networkId = ""; + std::string dhId = ""; + EnableParam param; + IDistributedHardwareSource *sourcePtr = nullptr; + auto ret = compEnable->Enable(networkId, dhId, param, sourcePtr); + EXPECT_EQ(ret, ERR_DH_FWK_PARA_INVALID); + + networkId = "networkId_test"; + ret = compEnable->Enable(networkId, dhId, param, sourcePtr); + EXPECT_EQ(ret, ERR_DH_FWK_PARA_INVALID); + + networkId = ""; + dhId = "dhId_test"; + ret = compEnable->Enable(networkId, dhId, param, sourcePtr); + EXPECT_EQ(ret, ERR_DH_FWK_PARA_INVALID); +} + +HWTEST_F(ComponentEnableTest, Enable_002, testing::ext::TestSize.Level1) +{ + auto compEnable = std::make_shared(); + std::string networkId = "networkId_test"; + std::string dhId = "dhId_test"; + EnableParam param; + IDistributedHardwareSource *sourcePtr = nullptr; + auto ret = compEnable->Enable(networkId, dhId, param, sourcePtr); + EXPECT_EQ(ret, ERR_DH_FWK_PARA_INVALID); +} + +HWTEST_F(ComponentEnableTest, OnRegisterResult_001, testing::ext::TestSize.Level1) +{ + auto compEnable = std::make_shared(); + std::string networkId = ""; + std::string dhId = ""; + int32_t status = 0; + std::string data; + auto ret = compEnable->OnRegisterResult(networkId, dhId, status, data); + EXPECT_EQ(ret, ERR_DH_FWK_PARA_INVALID); + + networkId = "networkId_test"; + ret = compEnable->OnRegisterResult(networkId, dhId, status, data); + EXPECT_EQ(ret, ERR_DH_FWK_PARA_INVALID); + + networkId = ""; + dhId = "dhId_test"; + ret = compEnable->OnRegisterResult(networkId, dhId, status, data); + EXPECT_EQ(ret, ERR_DH_FWK_PARA_INVALID); +} + +HWTEST_F(ComponentEnableTest, OnRegisterResult_002, testing::ext::TestSize.Level1) +{ + auto compEnable = std::make_shared(); + std::string networkId = "networkId_test"; + std::string dhId = "dhId_test"; + int32_t status = 0; + std::string data; + auto ret = compEnable->OnRegisterResult(networkId, dhId, status, data); + EXPECT_EQ(ret, DH_FWK_SUCCESS); + + status = ENABLE_RESULT_FAILED; + ret = compEnable->OnRegisterResult(networkId, dhId, status, data); + EXPECT_EQ(ret, ENABLE_RESULT_FAILED); +} +} +} \ No newline at end of file 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 156aa6f36dce35180e34e38c7982b500f29f57de..0616ac1c86fbf534a147a32d5ba391732843fe0c 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 @@ -34,6 +34,8 @@ #include "dh_utils_tool.h" #include "distributed_hardware_errno.h" #include "distributed_hardware_log.h" +#include "dh_data_sync_trigger_listener.h" +#include "dh_state_listener.h" #include "local_capability_info_manager.h" #include "meta_capability_info.h" #include "meta_info_manager.h" @@ -1225,5 +1227,27 @@ HWTEST_F(ComponentManagerTest, UninitCompSink_001, TestSize.Level1) SetDownComponentLoaderConfig(); EXPECT_EQ(ret, ERR_DH_FWK_LOADER_SINK_UNLOAD); } + +HWTEST_F(ComponentManagerTest, OnDataSyncTrigger_001, testing::ext::TestSize.Level1) +{ + DHDataSyncTriggerListener dhDataSyncTrigger; + std::string networkId = ""; + ASSERT_NO_FATAL_FAILURE(dhDataSyncTrigger.OnDataSyncTrigger(networkId)); + + networkId = "networkId_test"; + ASSERT_NO_FATAL_FAILURE(dhDataSyncTrigger.OnDataSyncTrigger(networkId)); +} + +HWTEST_F(ComponentManagerTest, OnStateChanged_001, testing::ext::TestSize.Level1) +{ + DHStateListener dhStateListenenr; + std::string dhId = "dhId_test"; + BusinessState state = BusinessState::UNKNOWN; + std::string networkId = ""; + ASSERT_NO_FATAL_FAILURE(dhStateListenenr.OnStateChanged(networkId, dhId, state)); + + networkId = "networkId_test"; + ASSERT_NO_FATAL_FAILURE(dhStateListenenr.OnStateChanged(networkId, dhId, state)); +} } // namespace DistributedHardware } // namespace OHOS diff --git a/services/distributedhardwarefwkservice/test/unittest/common/transport/dh_comm_tool_test.cpp b/services/distributedhardwarefwkservice/test/unittest/common/transport/dh_comm_tool_test.cpp index 3841d566983ebf2b752382b1a8694ffc4e54d606..94b22cb259e5851417bd2a927cc39daea70951de 100644 --- a/services/distributedhardwarefwkservice/test/unittest/common/transport/dh_comm_tool_test.cpp +++ b/services/distributedhardwarefwkservice/test/unittest/common/transport/dh_comm_tool_test.cpp @@ -18,6 +18,8 @@ #include #include +#include "capability_info.h" +#include "capability_info_manager.h" #include "dh_context.h" #include "dh_transport_obj.h" #include "dh_utils_tool.h" @@ -28,6 +30,7 @@ using namespace testing::ext; namespace OHOS { namespace DistributedHardware { using namespace std; +constexpr uint16_t TEST_DEV_TYPE = 0x14; class DhCommToolTest : public testing::Test { public: @@ -115,22 +118,72 @@ HWTEST_F(DhCommToolTest, ParseAndSaveRemoteDHCaps_002, TestSize.Level1) HWTEST_F(DhCommToolTest, ProcessEvent_001, TestSize.Level1) { + std::shared_ptr dhCommToolPtr = nullptr; std::shared_ptr commMsg = std::make_shared(); std::shared_ptr runner = AppExecFwk::EventRunner::Create(true); - DHCommTool::DHCommToolEventHandler eventHandler(runner, dhCommToolTest_); + DHCommTool::DHCommToolEventHandler eventHandler(runner, dhCommToolPtr); AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(DH_COMM_REQ_FULL_CAPS, commMsg); - eventHandler.ProcessEvent(event); + ASSERT_NO_FATAL_FAILURE(eventHandler.ProcessEvent(event)); +} + +HWTEST_F(DhCommToolTest, ProcessEvent_002, TestSize.Level1) +{ + std::shared_ptr commMsg = std::make_shared(); + std::shared_ptr runner = AppExecFwk::EventRunner::Create(true); + DHCommTool::DHCommToolEventHandler eventHandler(runner, dhCommToolTest_); + AppExecFwk::InnerEvent::Pointer event1 = AppExecFwk::InnerEvent::Get(DH_COMM_REQ_FULL_CAPS, commMsg); + ASSERT_NO_FATAL_FAILURE(eventHandler.ProcessEvent(event1)); + + AppExecFwk::InnerEvent::Pointer event2 = AppExecFwk::InnerEvent::Get(DH_COMM_RSP_FULL_CAPS, commMsg); + ASSERT_NO_FATAL_FAILURE(eventHandler.ProcessEvent(event2)); + + AppExecFwk::InnerEvent::Pointer event3 = AppExecFwk::InnerEvent::Get(0, commMsg); + ASSERT_NO_FATAL_FAILURE(eventHandler.ProcessEvent(event3)); +} + +HWTEST_F(DhCommToolTest, ProcessFullCapsRsp_001, TestSize.Level1) +{ + std::shared_ptr commMsg = std::make_shared(); + std::shared_ptr runner = AppExecFwk::EventRunner::Create(true); + DHCommTool::DHCommToolEventHandler eventHandler(runner, dhCommToolTest_); std::vector> caps; std::string networkId = ""; FullCapsRsp capsRsp(networkId, caps); - eventHandler.ProcessFullCapsRsp(capsRsp, dhCommToolTest_); - EXPECT_EQ("", capsRsp.networkId); + ASSERT_NO_FATAL_FAILURE(eventHandler.ProcessFullCapsRsp(capsRsp, dhCommToolTest_)); networkId = "networkId_test"; FullCapsRsp capsRsp1(networkId, caps); - eventHandler.ProcessFullCapsRsp(capsRsp1, dhCommToolTest_); - EXPECT_EQ("networkId_test", capsRsp1.networkId); + ASSERT_NO_FATAL_FAILURE(eventHandler.ProcessFullCapsRsp(capsRsp1, dhCommToolTest_)); +} + +HWTEST_F(DhCommToolTest, ProcessFullCapsRsp_002, TestSize.Level1) +{ + std::shared_ptr commMsg = std::make_shared(); + std::shared_ptr runner = AppExecFwk::EventRunner::Create(true); + DHCommTool::DHCommToolEventHandler eventHandler(runner, dhCommToolTest_); + + std::vector> caps; + std::string networkId = "networkId_test"; + std::string dhId = "Camera_0"; + std::string devId = "123456789"; + std::string devName = "dev_pad"; + std::string dhAttrs = "attr"; + std::string subType = "camera"; + std::shared_ptr capInfoTest = make_shared(dhId, devId, devName, TEST_DEV_TYPE, DHType::CAMERA, dhAttrs, + subType); + caps.push_back(capInfoTest); + std::shared_ptr dhCommToolPtr = nullptr; + FullCapsRsp capsRsp1(networkId, caps); + ASSERT_NO_FATAL_FAILURE(eventHandler.ProcessFullCapsRsp(capsRsp1, dhCommToolPtr)); + + ASSERT_NO_FATAL_FAILURE(eventHandler.ProcessFullCapsRsp(capsRsp1, dhCommToolTest_)); + + networkId = "333333"; + DHContext::GetInstance().AddOnlineDevice("111111", "222222", "333333"); + FullCapsRsp capsRsp2(networkId, caps); + ASSERT_NO_FATAL_FAILURE(eventHandler.ProcessFullCapsRsp(capsRsp2, dhCommToolTest_)); + DHContext::GetInstance().RemoveOnlineDeviceIdEntryByNetworkId(networkId); } } } \ No newline at end of file diff --git a/services/distributedhardwarefwkservice/test/unittest/common/transport/dh_transport_test.cpp b/services/distributedhardwarefwkservice/test/unittest/common/transport/dh_transport_test.cpp index 5b7cdb573821a51c89625b2958c380231b941f8e..e066219329b05db0f9cd687ad93912bc2d5fab0b 100644 --- a/services/distributedhardwarefwkservice/test/unittest/common/transport/dh_transport_test.cpp +++ b/services/distributedhardwarefwkservice/test/unittest/common/transport/dh_transport_test.cpp @@ -226,7 +226,17 @@ HWTEST_F(DhTransportTest, GetRemoteNetworkIdBySocketId_001, TestSize.Level1) dhTransportTest_->HandleReceiveMessage(payload); payload = "payload_test"; - dhTransportTest_->HandleReceiveMessage(payload); + cJSON *jsonObj = cJSON_CreateObject(); + std::string networkIdKey = "networkId"; + ASSERT_TRUE(jsonObj != nullptr); + cJSON_AddStringToObject(jsonObj, networkIdKey.c_str(), "111111"); + char* cjson = cJSON_PrintUnformatted(jsonObj); + if (cjson == nullptr) { + cJSON_Delete(jsonObj); + return; + } + std::string jsonStr(cjson); + ASSERT_NO_FATAL_FAILURE(dhTransportTest_->HandleReceiveMessage(jsonStr)); } HWTEST_F(DhTransportTest, ToJson_FullCapsRsp_001, TestSize.Level1) @@ -320,5 +330,12 @@ HWTEST_F(DhTransportTest, FromJson_CommMsg_002, TestSize.Level1) cJSON_Delete(jsonObject); EXPECT_TRUE(commMsg.msg.empty()); } + +HWTEST_F(DhTransportTest, CreateClientSocket_001, TestSize.Level1) +{ + std::string remoteNetworkId = ""; + auto ret = dhTransportTest_->CreateClientSocket(remoteNetworkId); + EXPECT_EQ(ERR_DH_FWK_PARA_INVALID, ret); +} } } \ No newline at end of file