From 91535a4f8e838c159fec0c64c830da2064a301eb Mon Sep 17 00:00:00 2001 From: LiangNuo Date: Mon, 16 Jun 2025 20:13:24 +0800 Subject: [PATCH 01/12] modify format Signed-off-by: LiangNuo --- test/unittest/mock/accesstoken_kit_mock.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/test/unittest/mock/accesstoken_kit_mock.cpp b/test/unittest/mock/accesstoken_kit_mock.cpp index 8475fc5f3..31e987215 100644 --- a/test/unittest/mock/accesstoken_kit_mock.cpp +++ b/test/unittest/mock/accesstoken_kit_mock.cpp @@ -35,9 +35,9 @@ int AccessTokenKit::GetNativeTokenInfo(AccessTokenID tokenID, NativeTokenInfo &n return AccessTokenKitInterface::GetOrCreateAccessTokenKit()->GetNativeTokenInfo(tokenID, nativeTokenInfoRes); } -AccessTokenID AccessTokenKit::GetNativeTokenId(const std::string &GetNativeTokenId) +AccessTokenID AccessTokenKit::GetNativeTokenId(const std::string &nativeTokenId) { - return AccessTokenKitInterface::GetOrCreateAccessTokenKit()->GetNativeTokenId(GetNativeTokenId); + return AccessTokenKitInterface::GetOrCreateAccessTokenKit()->GetNativeTokenId(nativeTokenId); } AccessTokenID AccessTokenKit::GetHapTokenID(int32_t userID, const std::string &bundleName, int32_t instIndex) -- Gitee From 64170c1618df644091f9bd5fbc6d359566dbbd9d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=BC=A0=E9=9B=B7?= Date: Thu, 3 Jul 2025 14:03:49 +0800 Subject: [PATCH 02/12] pr modify MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 张雷 --- utils/src/kvadapter/kv_adapter.cpp | 3 +++ 1 file changed, 3 insertions(+) diff --git a/utils/src/kvadapter/kv_adapter.cpp b/utils/src/kvadapter/kv_adapter.cpp index b2affd783..f61f88ada 100644 --- a/utils/src/kvadapter/kv_adapter.cpp +++ b/utils/src/kvadapter/kv_adapter.cpp @@ -39,6 +39,9 @@ namespace { constexpr int32_t MAX_STRING_LEN = 4096; constexpr int32_t MAX_INIT_RETRY_TIMES = 20; constexpr int32_t INIT_RETRY_SLEEP_INTERVAL = 200 * 1000; // 200ms + const char* PEER_UDID = "peer_udid"; + const char* PEER_OSTYPE = "peer_os_type"; + const char* TIME_STAMP = "timestamp"; } int32_t KVAdapter::Init() -- Gitee From b7a32ba8195624e6f877032591456181815a89f5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=BC=A0=E9=9B=B7?= Date: Thu, 3 Jul 2025 06:09:48 +0000 Subject: [PATCH 03/12] Revert "pr modify" This reverts commit 64170c1618df644091f9bd5fbc6d359566dbbd9d. --- utils/src/kvadapter/kv_adapter.cpp | 3 --- 1 file changed, 3 deletions(-) diff --git a/utils/src/kvadapter/kv_adapter.cpp b/utils/src/kvadapter/kv_adapter.cpp index f61f88ada..b2affd783 100644 --- a/utils/src/kvadapter/kv_adapter.cpp +++ b/utils/src/kvadapter/kv_adapter.cpp @@ -39,9 +39,6 @@ namespace { constexpr int32_t MAX_STRING_LEN = 4096; constexpr int32_t MAX_INIT_RETRY_TIMES = 20; constexpr int32_t INIT_RETRY_SLEEP_INTERVAL = 200 * 1000; // 200ms - const char* PEER_UDID = "peer_udid"; - const char* PEER_OSTYPE = "peer_os_type"; - const char* TIME_STAMP = "timestamp"; } int32_t KVAdapter::Init() -- Gitee From 870a5ac2c4e55347cdef331e81b272d3f25eee7c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=BC=A0=E9=9B=B7?= Date: Tue, 8 Jul 2025 14:35:30 +0800 Subject: [PATCH 04/12] add log MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 张雷 --- services/service/src/device_manager_service.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/services/service/src/device_manager_service.cpp b/services/service/src/device_manager_service.cpp index c32ff62d2..804d0a733 100644 --- a/services/service/src/device_manager_service.cpp +++ b/services/service/src/device_manager_service.cpp @@ -1591,6 +1591,7 @@ int32_t DeviceManagerService::StopAdvertising(const std::string &pkgName, int32_t DeviceManagerService::BindTarget(const std::string &pkgName, const PeerTargetId &targetId, const std::map &bindParam) { + LOGI("DeviceManagerService::BindTarget"); if (!PermissionManager::GetInstance().CheckNewPermission()) { LOGE("The caller does not have permission to call"); return ERR_DM_NO_PERMISSION; -- Gitee From 7a5585d2c4f8dbbf3a94fbd64e5da87723458de6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=BC=A0=E9=9B=B7?= Date: Tue, 8 Jul 2025 06:37:58 +0000 Subject: [PATCH 05/12] Revert "add log" This reverts commit 870a5ac2c4e55347cdef331e81b272d3f25eee7c. --- services/service/src/device_manager_service.cpp | 1 - 1 file changed, 1 deletion(-) diff --git a/services/service/src/device_manager_service.cpp b/services/service/src/device_manager_service.cpp index 804d0a733..c32ff62d2 100644 --- a/services/service/src/device_manager_service.cpp +++ b/services/service/src/device_manager_service.cpp @@ -1591,7 +1591,6 @@ int32_t DeviceManagerService::StopAdvertising(const std::string &pkgName, int32_t DeviceManagerService::BindTarget(const std::string &pkgName, const PeerTargetId &targetId, const std::map &bindParam) { - LOGI("DeviceManagerService::BindTarget"); if (!PermissionManager::GetInstance().CheckNewPermission()) { LOGE("The caller does not have permission to call"); return ERR_DM_NO_PERMISSION; -- Gitee From 27751039771e45247c85fcc3acd89314ad5f41bb Mon Sep 17 00:00:00 2001 From: wym <14509651+i-know-what-to-do@user.noreply.gitee.com> Date: Tue, 26 Aug 2025 16:53:17 +0800 Subject: [PATCH 06/12] DM_TDD --- .../device_manager_notify_fuzzer.cpp | 50 ++ .../devicemanagerservice_fuzzer/BUILD.gn | 1 + .../device_manager_service_fuzzer.cpp | 47 ++ .../devicemanagerserviceimpl_fuzzer/BUILD.gn | 97 ++++ .../corpus/init | 13 + .../device_manager_service_impl_fuzzer.cpp | 45 ++ .../device_manager_service_impl_fuzzer.h | 31 ++ .../project.xml | 25 + .../BUILD.gn | 92 ++++ .../corpus/init | 13 + ...device_manager_service_listener_fuzzer.cpp | 48 ++ .../device_manager_service_listener_fuzzer.h | 21 + .../project.xml | 25 + .../device_profile_connector_fuzzer.cpp | 62 +++ .../ipc_model_codec_fuzzer.cpp | 111 ++++ test/unittest/BUILD.gn | 5 +- .../UTTest_device_manager_notify_four.cpp | 242 +++++++++ .../UTTest_device_manager_service.cpp | 334 +++++++++++- .../UTTest_device_manager_service_impl.cpp | 118 ++--- ...UTTest_device_manager_service_listener.cpp | 45 ++ test/unittest/UTTest_device_manager_utils.cpp | 113 ++++ test/unittest/UTTest_device_manager_utils.h | 76 +++ test/unittest/UTTest_dm_pin_holder.cpp | 3 +- test/unittest/UTTest_dm_pin_holder.h | 10 + .../UTTest_ipc_cmd_parser_service.cpp | 481 ++++++++++++++++++ test/unittest/device_manager_impl_test.cpp | 294 +++++++++++ test/unittest/device_manager_impl_test.h | 48 +- .../mock/device_manager_service_impl_mock.h | 14 + .../mock/deviceprofile_connector_mock.h | 5 + test/unittest/mock/dm_crypto_mock.h | 1 + test/unittest/mock/ipc_cmd_register_mock.h | 1 + .../mock/ipc_server_listener_mock.cpp | 3 + test/unittest/mock/ipc_server_listener_mock.h | 2 + 33 files changed, 2388 insertions(+), 88 deletions(-) create mode 100644 test/servicesfuzztest/devicemanagerserviceimpl_fuzzer/BUILD.gn create mode 100644 test/servicesfuzztest/devicemanagerserviceimpl_fuzzer/corpus/init create mode 100644 test/servicesfuzztest/devicemanagerserviceimpl_fuzzer/device_manager_service_impl_fuzzer.cpp create mode 100644 test/servicesfuzztest/devicemanagerserviceimpl_fuzzer/device_manager_service_impl_fuzzer.h create mode 100644 test/servicesfuzztest/devicemanagerserviceimpl_fuzzer/project.xml create mode 100644 test/servicesfuzztest/devicemanagerservicelistener_fuzzer/BUILD.gn create mode 100644 test/servicesfuzztest/devicemanagerservicelistener_fuzzer/corpus/init create mode 100644 test/servicesfuzztest/devicemanagerservicelistener_fuzzer/device_manager_service_listener_fuzzer.cpp create mode 100644 test/servicesfuzztest/devicemanagerservicelistener_fuzzer/device_manager_service_listener_fuzzer.h create mode 100644 test/servicesfuzztest/devicemanagerservicelistener_fuzzer/project.xml create mode 100644 test/unittest/UTTest_device_manager_notify_four.cpp create mode 100644 test/unittest/UTTest_device_manager_utils.cpp create mode 100644 test/unittest/UTTest_device_manager_utils.h diff --git a/test/servicesfuzztest/devicemanagernotify_fuzzer/device_manager_notify_fuzzer.cpp b/test/servicesfuzztest/devicemanagernotify_fuzzer/device_manager_notify_fuzzer.cpp index a2b74f3e5..6c44d65ce 100644 --- a/test/servicesfuzztest/devicemanagernotify_fuzzer/device_manager_notify_fuzzer.cpp +++ b/test/servicesfuzztest/devicemanagernotify_fuzzer/device_manager_notify_fuzzer.cpp @@ -36,9 +36,21 @@ #include "dm_constants.h" #include "system_ability_definition.h" #include "device_manager_notify_fuzzer.h" +#include namespace OHOS { namespace DistributedHardware { +class MockServicePublishCallback : public ServicePublishCallback { +public: + void OnServicePublishResult(int64_t serviceId, int32_t reason) override + { + lastServiceId_ = serviceId; + lastReason_ = reason; + } + int64_t lastServiceId_ = 0; + int32_t lastReason_ = 0; +}; + void DeviceManagerNotifyUnRegisterFuzzTest(const uint8_t* data, size_t size) { if ((data == nullptr) || (size == 0)) { @@ -102,6 +114,41 @@ void DeviceManagerNotifyOnPublishResultFuzzTest(const uint8_t* data, size_t size DeviceManagerNotify::GetInstance().OnPublishResult(pkgName, publishId, publishResult); } + +void RegisterServicePublishCallbackFuzzTest(const uint8_t* data, size_t size) +{ + if ((data == nullptr) || (size == 0)) { + return; + } + + FuzzedDataProvider fdp(data, size); + int64_t serviceId = fdp.ConsumeIntegral(); + auto callback = std::make_shared(); + DeviceManagerNotify::GetInstance().RegisterServicePublishCallback(serviceId, callback); +} + +void UnRegisterServicePublishCallbackFuzzTest(const uint8_t* data, size_t size) +{ + if ((data == nullptr) || (size == 0)) { + return; + } + + FuzzedDataProvider fdp(data, size); + int64_t serviceId = fdp.ConsumeIntegral(); + DeviceManagerNotify::GetInstance().UnRegisterServicePublishCallback(serviceId); +} + +void OnServicePublishResultFuzzTest(const uint8_t* data, size_t size) +{ + if ((data == nullptr) || (size == 0)) { + return; + } + + FuzzedDataProvider fdp(data, size); + int64_t serviceId = fdp.ConsumeIntegral(); + int32_t publishResult = fdp.ConsumeIntegral(); + DeviceManagerNotify::GetInstance().OnServicePublishResult(serviceId, publishResult); +} } } @@ -112,6 +159,9 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) OHOS::DistributedHardware::DeviceManagerNotifyUnRegisterFuzzTest(data, size); OHOS::DistributedHardware::DeviceManagerNotifyDeviceStatusFuzzTest(data, size); OHOS::DistributedHardware::DeviceManagerNotifyOnPublishResultFuzzTest(data, size); + OHOS::DistributedHardware::RegisterServicePublishCallbackFuzzTest(data, size); + OHOS::DistributedHardware::UnRegisterServicePublishCallbackFuzzTest(data, size); + OHOS::DistributedHardware::OnServicePublishResultFuzzTest(data, size); return 0; } diff --git a/test/servicesfuzztest/devicemanagerservice_fuzzer/BUILD.gn b/test/servicesfuzztest/devicemanagerservice_fuzzer/BUILD.gn index 21041b11a..32a91f35e 100644 --- a/test/servicesfuzztest/devicemanagerservice_fuzzer/BUILD.gn +++ b/test/servicesfuzztest/devicemanagerservice_fuzzer/BUILD.gn @@ -60,6 +60,7 @@ ohos_fuzztest("DeviceManagerServiceFuzzTest") { deps = [ "${devicemanager_path}/services/service:devicemanagerservicetest", "${utils_path}:devicemanagerutilstest", + "${devicemanager_path}/services/implementation:devicemanagerserviceimpl", ] defines = [ diff --git a/test/servicesfuzztest/devicemanagerservice_fuzzer/device_manager_service_fuzzer.cpp b/test/servicesfuzztest/devicemanagerservice_fuzzer/device_manager_service_fuzzer.cpp index 749ed9e22..7291f39b7 100644 --- a/test/servicesfuzztest/devicemanagerservice_fuzzer/device_manager_service_fuzzer.cpp +++ b/test/servicesfuzztest/devicemanagerservice_fuzzer/device_manager_service_fuzzer.cpp @@ -17,6 +17,7 @@ #include #include "device_manager_service.h" #include "device_manager_service_fuzzer.h" +#include namespace OHOS { namespace DistributedHardware { @@ -25,6 +26,7 @@ void DeviceManagerServiceFuzzTest(const uint8_t* data, size_t size) if ((data == nullptr) || (size < sizeof(int32_t))) { return; } + FuzzedDataProvider fdp(data, size); int sessionId = *(reinterpret_cast(data)); std::string inputStr(reinterpret_cast(data), size); std::string retStr; @@ -37,6 +39,40 @@ void DeviceManagerServiceFuzzTest(const uint8_t* data, size_t size) subscribeInfo.subscribeId = 1; DmPublishInfo publishInfo; std::map parametricMap; + int64_t serviceId = fdp.ConsumeIntegral(); + int64_t internalServiceId = fdp.ConsumeIntegral(); + PublishServiceParam publishServiceParam; + publishServiceParam.serviceInfo.serviceId = fdp.ConsumeIntegral(); + publishServiceParam.serviceInfo.serviceType = fdp.ConsumeIntegral(); + publishServiceParam.serviceInfo.serviceName = fdp.ConsumeRandomLengthString(); + publishServiceParam.serviceInfo.serviceDisplayName = fdp.ConsumeRandomLengthString(); + ServiceRegInfo serviceRegInfo; + serviceRegInfo.serviceInfo.serviceId = fdp.ConsumeIntegral(); + serviceRegInfo.serviceInfo.serviceType = fdp.ConsumeIntegral(); + serviceRegInfo.serviceInfo.serviceName = fdp.ConsumeRandomLengthString(); + serviceRegInfo.serviceInfo.serviceDisplayName = fdp.ConsumeRandomLengthString(); + int32_t regServiceId = 0; + int64_t publishServiceId = 0; + int64_t fuzzServiceId = 0; + ServiceBindLocalInfo localInfo; + localInfo.localUdid = fdp.ConsumeRandomLengthString(); + localInfo.userId = fdp.ConsumeIntegral(); + localInfo.tokenId = fdp.ConsumeIntegral(); + int32_t fuzzUserId = fdp.ConsumeIntegral(); + PublishServiceParam fuzzPublishServiceParam; + fuzzPublishServiceParam.regServiceId = fdp.ConsumeIntegral(); + fuzzPublishServiceParam.serviceInfo.serviceId = fdp.ConsumeIntegral(); + fuzzPublishServiceParam.serviceInfo.serviceType = fdp.ConsumeRandomLengthString(); + fuzzPublishServiceParam.serviceInfo.serviceName = fdp.ConsumeRandomLengthString(); + fuzzPublishServiceParam.serviceInfo.serviceDisplayName = fdp.ConsumeRandomLengthString(); + int32_t fuzzUserId2 = fdp.ConsumeIntegral(); + ServiceInfoProfile fuzzServiceInfoProfile; + fuzzServiceInfoProfile.serviceId = fuzzServiceId; + fuzzServiceInfoProfile.userId = fuzzUserId2; + fuzzServiceInfoProfile.serviceName = fdp.ConsumeRandomLengthString(); + fuzzServiceInfoProfile.serviceType = fdp.ConsumeRandomLengthString(); + int32_t fuzzRegServiceId = 0; + std::string pkgName = "com.example.fuzz." + std::to_string(rand()); DeviceManagerService::GetInstance().PublishDeviceDiscovery(inputStr, publishInfo); DeviceManagerService::GetInstance().RequestCredential(inputStr, inputStr); @@ -67,6 +103,17 @@ void DeviceManagerServiceFuzzTest(const uint8_t* data, size_t size) DeviceManagerService::GetInstance().DeleteCredential(inputStr, inputStr, inputStr); DeviceManagerService::GetInstance().DpAclAdd(inputStr); DeviceManagerService::GetInstance().GetLocalDeviceName(retStr); + DeviceManagerService::GetInstance().StopPublishServiceInternal(internalServiceId); + DeviceManagerService::GetInstance().RegisterServiceInfo(serviceRegInfo, regServiceId); + DeviceManagerService::GetInstance().UnRegisterServiceInfo(regServiceId); + DeviceManagerService::GetInstance().StartPublishService(pkgName, publishServiceParam, publishServiceId); + DeviceManagerService::GetInstance().StopPublishService(publishServiceId); + DeviceManagerService::GetInstance().StopPublishServiceInternal(internalServiceId); + DeviceManagerService::GetInstance().GenerateServiceId(fuzzServiceId); + DeviceManagerService::GetInstance().GetServiceBindLocalInfo(localInfo); + DeviceManagerService::GetInstance().CreateServiceInfoProfile(fuzzPublishServiceParam, fuzzUserId2); + DeviceManagerService::GetInstance().ConvertServiceInfoProfileByRegInfo(serviceRegInfo, fuzzServiceInfoProfile); + DeviceManagerService::GetInstance().GenerateRegServiceId(fuzzRegServiceId); } } } diff --git a/test/servicesfuzztest/devicemanagerserviceimpl_fuzzer/BUILD.gn b/test/servicesfuzztest/devicemanagerserviceimpl_fuzzer/BUILD.gn new file mode 100644 index 000000000..81c702bfa --- /dev/null +++ b/test/servicesfuzztest/devicemanagerserviceimpl_fuzzer/BUILD.gn @@ -0,0 +1,97 @@ +# Copyright (c) 2022-2024 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. + +#####################hydra-fuzz################### +import("//build/config/features.gni") +import("//build/test.gni") +import("//foundation/distributedhardware/device_manager/device_manager.gni") + +##############################fuzztest########################################## +ohos_fuzztest("DeviceManagerServiceImplFuzzTest") { + module_out_path = fuzz_test_output_path + fuzz_config_file = + "${devicemanager_path}/test/servicesfuzztest/devicemanagerserviceimpl_fuzzer" + + include_dirs = [ + "${innerkits_path}/native_cpp/include", + "${innerkits_path}/native_cpp/include/ipc/standard", + "${innerkits_path}/native_cpp/include/ipc", + "${innerkits_path}/native_cpp/include/notify", + "${common_path}/include", + "${common_path}/include/ipc", + "${common_path}/include/ipc/model", + "${utils_path}/include", + "${utils_path}/include/ipc/standard", + "${servicesimpl_path}/include", + "${servicesimpl_path}/include/dependency/timer", + "${servicesimpl_path}/include/discovery", + "${servicesimpl_path}/include/dependency/softbus", + "${servicesimpl_path}/include/authentication", + "${servicesimpl_path}/include/adapter", + "${servicesimpl_path}/include/ipc/standard", + "${servicesimpl_path}/include/dependency/hichain", + "${servicesimpl_path}/include/deviceinfo/", + "${servicesimpl_path}/include/devicestate", + "${servicesimpl_path}/include/ability", + "${servicesimpl_path}/include/config", + ] + + cflags = [ + "-g", + "-O0", + "-Dprivate=public", + "-Dprotected=public", + "-Werror", + "-Wno-unused-variable", + "-fno-omit-frame-pointer", + "-fsanitize=address", + "-fsanitize=undefined", + "-fno-sanitize-recover=all", + ] + sources = [ "device_manager_service_impl_fuzzer.cpp" ] + + deps = [ + "${devicemanager_path}/services/service:devicemanagerservicetest", + "${utils_path}:devicemanagerutilstest", + "${devicemanager_path}/services/implementation:devicemanagerserviceimpl", + "${devicemanager_path}/commondependency:deviceprofile_connector", + ] + + defines = [ + "HI_LOG_ENABLE", + "DH_LOG_TAG=\"DeviceManagerServiceImplFuzzTest\"", + "LOG_DOMAIN=0xD004110", + ] + + external_deps = [ + "ability_base:want", + "cJSON:cjson", + "device_auth:deviceauth_sdk", + "device_info_manager:distributed_device_profile_common", + "device_info_manager:distributed_device_profile_sdk", + "dsoftbus:softbus_client", + "ffrt:libffrt", + "hilog:libhilog", + "init:libbegetutil", + "ipc:ipc_single", + "safwk:system_ability_fwk", + ] +} + +############################################################################### +group("fuzztest") { + testonly = true + + deps = [ ":DeviceManagerServiceImplFuzzTest" ] +} +############################################################################### diff --git a/test/servicesfuzztest/devicemanagerserviceimpl_fuzzer/corpus/init b/test/servicesfuzztest/devicemanagerserviceimpl_fuzzer/corpus/init new file mode 100644 index 000000000..59aefb51c --- /dev/null +++ b/test/servicesfuzztest/devicemanagerserviceimpl_fuzzer/corpus/init @@ -0,0 +1,13 @@ +# Copyright (c) 2020-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. +FUZZ \ No newline at end of file diff --git a/test/servicesfuzztest/devicemanagerserviceimpl_fuzzer/device_manager_service_impl_fuzzer.cpp b/test/servicesfuzztest/devicemanagerserviceimpl_fuzzer/device_manager_service_impl_fuzzer.cpp new file mode 100644 index 000000000..41f49a193 --- /dev/null +++ b/test/servicesfuzztest/devicemanagerserviceimpl_fuzzer/device_manager_service_impl_fuzzer.cpp @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2022-2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * 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 +#include "device_manager_service_impl_fuzzer.h" +#include + + +namespace OHOS { +namespace DistributedHardware { +void DeviceManagerServiceImplFuzzTest(const uint8_t* data, size_t size) +{ + if ((data == nullptr) || (size < sizeof(int64_t))) { + return; + } + FuzzedDataProvider fdp(data, size); + + // Test HandleStopPublishService + int64_t serviceId = fdp.ConsumeIntegral(); + DeviceManagerServiceImpl::GetInstance().HandleStopPublishService(serviceId); +} +} +} + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) +{ + /* Run your code on data */ + OHOS::DistributedHardware::DeviceManagerServiceImplFuzzTest(data, size); + + return 0; +} \ No newline at end of file diff --git a/test/servicesfuzztest/devicemanagerserviceimpl_fuzzer/device_manager_service_impl_fuzzer.h b/test/servicesfuzztest/devicemanagerserviceimpl_fuzzer/device_manager_service_impl_fuzzer.h new file mode 100644 index 000000000..f4ff8b7df --- /dev/null +++ b/test/servicesfuzztest/devicemanagerserviceimpl_fuzzer/device_manager_service_impl_fuzzer.h @@ -0,0 +1,31 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef DEVICE_MANAGER_SERVICE_IMPL_FUZZER_H +#define DEVICE_MANAGER_SERVICE_IMPL_FUZZER_H + +#include +#include +#include + +#include "device_manager_service_impl.h" +#include "deviceprofile_connector.h" +#include "access_control_profile.h" +#include "json_object.h" +#include "dm_log.h" + +#define FUZZ_PROJECT_NAME "devicemanagerserviceimpl_fuzzer" + +#endif // DEVICE_MANAGER_SERVICE_IMPL_FUZZER_H \ No newline at end of file diff --git a/test/servicesfuzztest/devicemanagerserviceimpl_fuzzer/project.xml b/test/servicesfuzztest/devicemanagerserviceimpl_fuzzer/project.xml new file mode 100644 index 000000000..27c26d11b --- /dev/null +++ b/test/servicesfuzztest/devicemanagerserviceimpl_fuzzer/project.xml @@ -0,0 +1,25 @@ + + + + + + 1000 + + 300 + + 4096 + + \ No newline at end of file diff --git a/test/servicesfuzztest/devicemanagerservicelistener_fuzzer/BUILD.gn b/test/servicesfuzztest/devicemanagerservicelistener_fuzzer/BUILD.gn new file mode 100644 index 000000000..365646892 --- /dev/null +++ b/test/servicesfuzztest/devicemanagerservicelistener_fuzzer/BUILD.gn @@ -0,0 +1,92 @@ +# Copyright (c) 2022-2024 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. + +#####################hydra-fuzz################### +import("//build/config/features.gni") +import("//build/test.gni") +import("//foundation/distributedhardware/device_manager/device_manager.gni") + +##############################fuzztest########################################## +ohos_fuzztest("DeviceManagerServiceListenerFuzzTest") { + module_out_path = fuzz_test_output_path + fuzz_config_file = + "${devicemanager_path}/test/servicesfuzztest/devicemanagerservicelistener_fuzzer" + + include_dirs = [ + "${innerkits_path}/native_cpp/include", + "${innerkits_path}/native_cpp/include/ipc/standard", + "${innerkits_path}/native_cpp/include/ipc", + "${innerkits_path}/native_cpp/include/notify", + "${common_path}/include", + "${common_path}/include/ipc", + "${common_path}/include/ipc/model", + "${utils_path}/include", + "${utils_path}/include/ipc/standard", + "${servicesimpl_path}/include", + "${servicesimpl_path}/include/dependency/timer", + "${servicesimpl_path}/include/discovery", + "${servicesimpl_path}/include/dependency/softbus", + "${servicesimpl_path}/include/authentication", + "${servicesimpl_path}/include/adapter", + "${servicesimpl_path}/include/ipc/standard", + "${servicesimpl_path}/include/dependency/hichain", + "${servicesimpl_path}/include/deviceinfo/", + "${servicesimpl_path}/include/devicestate", + "${servicesimpl_path}/include/ability", + "${servicesimpl_path}/include/config", + ] + + cflags = [ + "-g", + "-O0", + "-Dprivate=public", + "-Dprotected=public", + "-Werror", + "-Wno-unused-variable", + "-fno-omit-frame-pointer", + ] + sources = [ "device_manager_service_listener_fuzzer.cpp" ] + + deps = [ + "${devicemanager_path}/services/service:devicemanagerservicetest", + "${utils_path}:devicemanagerutilstest", + ] + + defines = [ + "HI_LOG_ENABLE", + "DH_LOG_TAG=\"DeviceManagerServiceListenerFuzzTest\"", + "LOG_DOMAIN=0xD004110", + ] + + external_deps = [ + "ability_base:want", + "cJSON:cjson", + "device_auth:deviceauth_sdk", + "device_info_manager:distributed_device_profile_common", + "device_info_manager:distributed_device_profile_sdk", + "dsoftbus:softbus_client", + "ffrt:libffrt", + "hilog:libhilog", + "init:libbegetutil", + "ipc:ipc_single", + "safwk:system_ability_fwk", + ] +} + +############################################################################### +group("fuzztest") { + testonly = true + + deps = [ ":DeviceManagerServiceListenerFuzzTest" ] +} +############################################################################### diff --git a/test/servicesfuzztest/devicemanagerservicelistener_fuzzer/corpus/init b/test/servicesfuzztest/devicemanagerservicelistener_fuzzer/corpus/init new file mode 100644 index 000000000..59aefb51c --- /dev/null +++ b/test/servicesfuzztest/devicemanagerservicelistener_fuzzer/corpus/init @@ -0,0 +1,13 @@ +# Copyright (c) 2020-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. +FUZZ \ No newline at end of file diff --git a/test/servicesfuzztest/devicemanagerservicelistener_fuzzer/device_manager_service_listener_fuzzer.cpp b/test/servicesfuzztest/devicemanagerservicelistener_fuzzer/device_manager_service_listener_fuzzer.cpp new file mode 100644 index 000000000..64344f1a5 --- /dev/null +++ b/test/servicesfuzztest/devicemanagerservicelistener_fuzzer/device_manager_service_listener_fuzzer.cpp @@ -0,0 +1,48 @@ +/* + * Copyright (c) 2022-2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * 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 +#include +#include "device_manager_service_listener_fuzzer.h" +#include "device_manager_service_listener.h" +#include + +namespace OHOS { +namespace DistributedHardware { +void DeviceManagerServiceListenerFuzzTest(const uint8_t* data, size_t size) +{ + FuzzedDataProvider fdp(data, size); + + int64_t serviceId = fdp.ConsumeIntegral(); + int32_t publishResult = fdp.ConsumeIntegral(); + std::string pkgName = fdp.ConsumeRandomLengthString(128); + int32_t pid = fdp.ConsumeIntegralInRange(0, 99999); + ProcessInfo processInfo; + processInfo.userId = pid; + processInfo.pkgName = pkgName; + + DeviceManagerServiceListener listener; + listener.OnServicePublishResult(processInfo, serviceId, publishResult); +} +} +} + +extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) +{ + OHOS::DistributedHardware::DeviceManagerServiceListenerFuzzTest(data, size); + + return 0; +} \ No newline at end of file diff --git a/test/servicesfuzztest/devicemanagerservicelistener_fuzzer/device_manager_service_listener_fuzzer.h b/test/servicesfuzztest/devicemanagerservicelistener_fuzzer/device_manager_service_listener_fuzzer.h new file mode 100644 index 000000000..ed67939cc --- /dev/null +++ b/test/servicesfuzztest/devicemanagerservicelistener_fuzzer/device_manager_service_listener_fuzzer.h @@ -0,0 +1,21 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef DEVICE_MANAGER_SERVICE_LISTENER_FUZZER_H +#define DEVICE_MANAGER_SERVICE_LISTENER_FUZZER_H + +#define FUZZ_PROJECT_NAME "devicemanagerservicelistener_fuzzer" + +#endif // DEVICE_MANAGER_SERVICE_FUZZER_H \ No newline at end of file diff --git a/test/servicesfuzztest/devicemanagerservicelistener_fuzzer/project.xml b/test/servicesfuzztest/devicemanagerservicelistener_fuzzer/project.xml new file mode 100644 index 000000000..0fea5df81 --- /dev/null +++ b/test/servicesfuzztest/devicemanagerservicelistener_fuzzer/project.xml @@ -0,0 +1,25 @@ + + + + + + 1000 + + 10 + + 4096 + + \ No newline at end of file diff --git a/test/servicesfuzztest/deviceprofileconnector_fuzzer/device_profile_connector_fuzzer.cpp b/test/servicesfuzztest/deviceprofileconnector_fuzzer/device_profile_connector_fuzzer.cpp index 5301a7178..d8e061ee5 100644 --- a/test/servicesfuzztest/deviceprofileconnector_fuzzer/device_profile_connector_fuzzer.cpp +++ b/test/servicesfuzztest/deviceprofileconnector_fuzzer/device_profile_connector_fuzzer.cpp @@ -20,6 +20,7 @@ #include "deviceprofile_connector.h" #include "device_profile_connector_fuzzer.h" #include +#include "dm_device_info.h" namespace OHOS { namespace DistributedHardware { @@ -66,6 +67,64 @@ void DeviceProfileConnectorFuzzTest(const uint8_t* data, size_t size) DeviceProfileConnector::GetInstance().DeleteTimeOutAcl(localDeviceId, offlineParam); DeviceProfileConnector::GetInstance().GetTrustNumber(localDeviceId); } + +void GetServiceInfoProfileByServiceIdFuzzTest(const uint8_t* data, size_t size) +{ + if ((data == nullptr) || (size < sizeof(uint32_t))) { + return; + } + + FuzzedDataProvider fdp(data, size); + int64_t serviceId = fdp.ConsumeIntegral(); + ServiceInfoProfile serviceInfoProfile; + serviceInfoProfile.regServiceId = fdp.ConsumeIntegral(); + serviceInfoProfile.deviceId = fdp.ConsumeRandomLengthString(1000); + serviceInfoProfile.userId = fdp.ConsumeIntegral(); + serviceInfoProfile.tokenId = fdp.ConsumeIntegral(); + serviceInfoProfile.publishState = fdp.ConsumeIntegral(); + serviceInfoProfile.serviceId = fdp.ConsumeIntegral(); + serviceInfoProfile.serviceType = fdp.ConsumeRandomLengthString(1000); + serviceInfoProfile.serviceName = fdp.ConsumeRandomLengthString(1000); + serviceInfoProfile.serviceDisplayName = fdp.ConsumeRandomLengthString(1000); + + DeviceProfileConnector::GetInstance().GetServiceInfoProfileByServiceId(serviceId, serviceInfoProfile); +} + +void PutServiceInfoProfileFuzzTest(const uint8_t* data, size_t size) +{ + if ((data == nullptr) || (size < sizeof(uint32_t))) { + return; + } + + FuzzedDataProvider fdp(data, size); + ServiceInfoProfile serviceInfoProfile; + serviceInfoProfile.regServiceId = fdp.ConsumeIntegral(); + serviceInfoProfile.deviceId = fdp.ConsumeRandomLengthString(64); + serviceInfoProfile.userId = fdp.ConsumeIntegral(); + serviceInfoProfile.tokenId = fdp.ConsumeIntegral(); + serviceInfoProfile.publishState = fdp.ConsumeIntegral(); + serviceInfoProfile.serviceId = fdp.ConsumeIntegral(); + serviceInfoProfile.serviceType = fdp.ConsumeRandomLengthString(64); + serviceInfoProfile.serviceName = fdp.ConsumeRandomLengthString(64); + serviceInfoProfile.serviceDisplayName = fdp.ConsumeRandomLengthString(64); + + DeviceProfileConnector::GetInstance().PutServiceInfoProfile(serviceInfoProfile); +} + +void DeleteServiceInfoProfileFuzzTest(const uint8_t* data, size_t size) +{ + if ((data == nullptr) || (size < sizeof(uint32_t))) { + return; + } + + FuzzedDataProvider fdp(data, size); + int32_t regServiceId = fdp.ConsumeIntegral(); + int32_t userId = fdp.ConsumeIntegral(); + bool isMultiUser = false; + isMultiUser = (reinterpret_cast(data)[0] != 0); + + DeviceProfileConnector::GetInstance().DeleteServiceInfoProfile(regServiceId, isMultiUser, userId); +} } } @@ -74,6 +133,9 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { /* Run your code on data */ OHOS::DistributedHardware::DeviceProfileConnectorFuzzTest(data, size); + OHOS::DistributedHardware::GetServiceInfoProfileByServiceIdFuzzTest(data, size); + OHOS::DistributedHardware::PutServiceInfoProfileFuzzTest(data, size); + OHOS::DistributedHardware::DeleteServiceInfoProfileFuzzTest(data, size); return 0; } \ No newline at end of file diff --git a/test/servicesfuzztest/ipcmodelcodec_fuzzer/ipc_model_codec_fuzzer.cpp b/test/servicesfuzztest/ipcmodelcodec_fuzzer/ipc_model_codec_fuzzer.cpp index 413d2fd01..fd92708d6 100644 --- a/test/servicesfuzztest/ipcmodelcodec_fuzzer/ipc_model_codec_fuzzer.cpp +++ b/test/servicesfuzztest/ipcmodelcodec_fuzzer/ipc_model_codec_fuzzer.cpp @@ -17,6 +17,7 @@ #include #include "ipc_model_codec.h" +#include "dm_device_info.h" namespace OHOS { @@ -749,6 +750,112 @@ void DecodeStringVectorFuzzTest(const uint8_t* data, size_t size) parcel.WriteUint32(invalidNum); ipcModelCodec->DecodeStringVector(invalidParcel, vec); } + +void EncodeServiceRegInfoFuzzTest(const uint8_t* data, size_t size) +{ + if ((data == nullptr) || (size < sizeof(uint32_t))) { + return; + } + FuzzedDataProvider fdp(data, size); + + uint32_t minRangeSize = 0; + uint32_t maxRangeSize = 1000; + MessageParcel parcel; + uint32_t num = fdp.ConsumeIntegralInRange(minRangeSize, maxRangeSize); + parcel.WriteUint32(num); + for (uint32_t i = 0; i < num; ++i) { + parcel.WriteString(fdp.ConsumeRandomLengthString(MAX_STRING_LENGTH)); + } + + ServiceRegInfo serRegInfo; + serRegInfo.customData = fdp.ConsumeRandomLengthString(MAX_STRING_LENGTH); + serRegInfo.dataLen = fdp.ConsumeIntegralInRange(minRangeSize, maxRangeSize); + serRegInfo.serviceInfo.serviceId = fdp.ConsumeIntegralInRange(minRangeSize, maxRangeSize); + serRegInfo.serviceInfo.serviceType = fdp.ConsumeRandomLengthString(MAX_STRING_LENGTH); + serRegInfo.serviceInfo.serviceName = fdp.ConsumeRandomLengthString(MAX_STRING_LENGTH); + serRegInfo.serviceInfo.serviceDisplayName = fdp.ConsumeRandomLengthString(MAX_STRING_LENGTH); + std::shared_ptr ipcModelCodec = std::make_shared(); + ipcModelCodec->EncodeServiceRegInfo(serRegInfo, parcel); +} + +void DecodeServiceRegInfoFuzzTest(const uint8_t* data, size_t size) +{ + if ((data == nullptr) || (size < sizeof(uint32_t))) { + return; + } + FuzzedDataProvider fdp(data, size); + + uint32_t minRangeSize = 0; + uint32_t maxRangeSize = 1000; + MessageParcel parcel; + uint32_t num = fdp.ConsumeIntegralInRange(minRangeSize, maxRangeSize); + parcel.WriteUint32(num); + for (uint32_t i = 0; i < num; ++i) { + parcel.WriteString(fdp.ConsumeRandomLengthString(MAX_STRING_LENGTH)); + } + + ServiceRegInfo serRegInfo; + serRegInfo.customData = fdp.ConsumeRandomLengthString(MAX_STRING_LENGTH); + serRegInfo.dataLen = fdp.ConsumeIntegralInRange(minRangeSize, maxRangeSize); + serRegInfo.serviceInfo.serviceId = fdp.ConsumeIntegralInRange(minRangeSize, maxRangeSize); + serRegInfo.serviceInfo.serviceType = fdp.ConsumeRandomLengthString(MAX_STRING_LENGTH); + serRegInfo.serviceInfo.serviceName = fdp.ConsumeRandomLengthString(MAX_STRING_LENGTH); + serRegInfo.serviceInfo.serviceDisplayName = fdp.ConsumeRandomLengthString(MAX_STRING_LENGTH); + std::shared_ptr ipcModelCodec = std::make_shared(); + ipcModelCodec->DecodeServiceRegInfo(parcel, serRegInfo); +} + +void EncodePublishServiceParamFuzzTest(const uint8_t* data, size_t size) +{ + if ((data == nullptr) || (size < sizeof(uint32_t))) { + return; + } + FuzzedDataProvider fdp(data, size); + + uint32_t minRangeSize = 0; + uint32_t maxRangeSize = 1000; + MessageParcel parcel; + uint32_t num = fdp.ConsumeIntegralInRange(minRangeSize, maxRangeSize); + parcel.WriteUint32(num); + for (uint32_t i = 0; i < num; ++i) { + parcel.WriteString(fdp.ConsumeRandomLengthString(MAX_STRING_LENGTH)); + } + + PublishServiceParam publishServiceParam; + publishServiceParam.regServiceId = fdp.ConsumeIntegralInRange(minRangeSize, maxRangeSize); + publishServiceParam.serviceInfo.serviceId = fdp.ConsumeIntegralInRange(minRangeSize, maxRangeSize); + publishServiceParam.serviceInfo.serviceType = fdp.ConsumeRandomLengthString(MAX_STRING_LENGTH); + publishServiceParam.serviceInfo.serviceName = fdp.ConsumeRandomLengthString(MAX_STRING_LENGTH); + publishServiceParam.serviceInfo.serviceDisplayName = fdp.ConsumeRandomLengthString(MAX_STRING_LENGTH); + std::shared_ptr ipcModelCodec = std::make_shared(); + ipcModelCodec->EncodePublishServiceParam(publishServiceParam, parcel); +} + +void DecodePublishServiceParamFuzzTest(const uint8_t* data, size_t size) +{ + if ((data == nullptr) || (size < sizeof(uint32_t))) { + return; + } + FuzzedDataProvider fdp(data, size); + + uint32_t minRangeSize = 0; + uint32_t maxRangeSize = 1000; + MessageParcel parcel; + uint32_t num = fdp.ConsumeIntegralInRange(minRangeSize, maxRangeSize); + parcel.WriteUint32(num); + for (uint32_t i = 0; i < num; ++i) { + parcel.WriteString(fdp.ConsumeRandomLengthString(MAX_STRING_LENGTH)); + } + + PublishServiceParam publishServiceParam; + publishServiceParam.regServiceId = fdp.ConsumeIntegralInRange(minRangeSize, maxRangeSize); + publishServiceParam.serviceInfo.serviceId = fdp.ConsumeIntegralInRange(minRangeSize, maxRangeSize); + publishServiceParam.serviceInfo.serviceType = fdp.ConsumeRandomLengthString(MAX_STRING_LENGTH); + publishServiceParam.serviceInfo.serviceName = fdp.ConsumeRandomLengthString(MAX_STRING_LENGTH); + publishServiceParam.serviceInfo.serviceDisplayName = fdp.ConsumeRandomLengthString(MAX_STRING_LENGTH); + std::shared_ptr ipcModelCodec = std::make_shared(); + ipcModelCodec->DecodePublishServiceParam(parcel, publishServiceParam); +} } } @@ -784,5 +891,9 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) OHOS::DistributedHardware::DecodeNetworkIdQueryFilterFuzzTest(data, size); OHOS::DistributedHardware::EncodeStringVectorFuzzTest(data, size); OHOS::DistributedHardware::DecodeStringVectorFuzzTest(data, size); + OHOS::DistributedHardware::EncodeServiceRegInfoFuzzTest(data, size); + OHOS::DistributedHardware::DecodeServiceRegInfoFuzzTest(data, size); + OHOS::DistributedHardware::EncodePublishServiceParamFuzzTest(data, size); + OHOS::DistributedHardware::DecodePublishServiceParamFuzzTest(data, size); return 0; } diff --git a/test/unittest/BUILD.gn b/test/unittest/BUILD.gn index 02d5243d7..f66b159a3 100644 --- a/test/unittest/BUILD.gn +++ b/test/unittest/BUILD.gn @@ -1,4 +1,4 @@ -# Copyright (c) 2022-2025 Huawei Device Co., Ltd. +# Copyright (c) 2022-2024 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 @@ -482,7 +482,6 @@ ohos_unittest("UTTest_device_manager_service") { "UTTest_device_manager_service_two.cpp", "mock/app_manager_mock.cpp", "mock/device_manager_service_impl_mock.cpp", - "mock/device_name_manager_mock.cpp", "mock/deviceprofile_connector_mock.cpp", "mock/dm_comm_tool_mock.cpp", "mock/dm_crypto_mock.cpp", @@ -500,7 +499,6 @@ ohos_unittest("UTTest_device_manager_service") { "access_token:libnativetoken", "access_token:libtoken_setproc", "cJSON:cjson", - "data_share:datashare_consumer", "device_auth:deviceauth_sdk", "device_info_manager:distributed_device_profile_common", "device_info_manager:distributed_device_profile_sdk", @@ -1269,6 +1267,7 @@ ohos_unittest("UTTest_device_manager_notify") { "UTTest_device_manager_notify.cpp", "UTTest_device_manager_notify_three.cpp", "UTTest_device_manager_notify_two.cpp", + "UTTest_device_manager_notify_four.cpp", ] deps = [ ":device_manager_test_common" ] diff --git a/test/unittest/UTTest_device_manager_notify_four.cpp b/test/unittest/UTTest_device_manager_notify_four.cpp new file mode 100644 index 000000000..6a0470e5c --- /dev/null +++ b/test/unittest/UTTest_device_manager_notify_four.cpp @@ -0,0 +1,242 @@ +/* + * Copyright (c) 2022-2023 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 "UTTest_device_manager_notify.h" +#include "device_manager_notify.h" +#include "dm_device_info.h" +#include "ipc_remote_broker.h" +#include "iremote_object.h" +#include "iservice_registry.h" +#include "system_ability_definition.h" +#include "ipc_client_manager.h" +#include "ipc_set_useroperation_req.h" +#include "ipc_rsp.h" +#include "ipc_def.h" +#include "device_manager_callback.h" + +#include + +#define MAX_CONTAINER_SIZE 1000 +#define DM_OK 0 + +namespace OHOS { +namespace DistributedHardware { +class MockServicePublishCallback : public ServicePublishCallback { +public: + bool isServicePublishResultCalled = false; + int64_t lastPublishId = 0; + int32_t lastResult; + + void OnServicePublishResult(int64_t publishId, int32_t result) override + { + isServicePublishResultCalled = true; + lastPublishId = publishId; + lastResult = result; + } + void reset() + { + isServicePublishResultCalled = false; + lastPublishId = 0; + lastResult = static_cast(0); + } +}; + +class TestServicePublishCallback : public ServicePublishCallback { +public: + int64_t lastPublishId = -1; + int32_t lastResult = static_cast(-1); + int callCount = 0; + std::mutex mtx; + + void OnServicePublishResult(int64_t publishId, int32_t result) override + { + std::lock_guard lock(mtx); + lastPublishId = publishId; + lastResult = result; + callCount++; + } +}; +namespace { + +/** + * @tc.name: RegisterServicePublishCallback_001 + * @tc.desc: 注册合法的回调对象 + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DeviceManagerNotifyTest, RegisterServicePublishCallback_001, testing::ext::TestSize.Level0) +{ + int64_t testPublishId = 1001; + std::shared_ptr mockCallback = std::make_shared(); + + DeviceManagerNotify::GetInstance().RegisterServicePublishCallback(testPublishId, mockCallback); + + std::lock_guard autoLock(DeviceManagerNotify::GetInstance().lock_); + auto& callbackMap = DeviceManagerNotify::GetInstance().servicePublishCallback_; + + EXPECT_EQ(callbackMap.count(testPublishId), 1); + EXPECT_EQ(callbackMap[testPublishId].get(), mockCallback.get()); +} + +/** + * @tc.name: RegisterServicePublishCallback_002 + * @tc.desc: 注册空回调对象 + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DeviceManagerNotifyTest, RegisterServicePublishCallback_002, testing::ext::TestSize.Level0) +{ + int64_t testPublishId = 1002; + std::shared_ptr nullCallback = nullptr; + DeviceManagerNotify::GetInstance().RegisterServicePublishCallback(testPublishId, nullCallback); + std::lock_guard autoLock(DeviceManagerNotify::GetInstance().lock_); + auto& callbackMap = DeviceManagerNotify::GetInstance().servicePublishCallback_; + EXPECT_EQ(callbackMap.count(testPublishId), 0); +} + +/** + * @tc.name: RegisterServicePublishCallback_003 + * @tc.desc: 注册回调到已满的容器 + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DeviceManagerNotifyTest, RegisterServicePublishCallback_003, testing::ext::TestSize.Level0) +{ + auto& notifyInstance = DeviceManagerNotify::GetInstance(); + { + std::lock_guard fillLock(notifyInstance.lock_); + auto& callbackMap = notifyInstance.servicePublishCallback_; + std::vector> callbacks; + + for (int64_t i = 0; i < MAX_CONTAINER_SIZE; ++i) { + auto callback = std::make_shared(); + callbackMap[i] = callback; + callbacks.push_back(callback); + } + } + int64_t newPublishId = MAX_CONTAINER_SIZE + 1; + auto newCallback = std::make_shared(); + notifyInstance.RegisterServicePublishCallback(newPublishId, newCallback); + { + std::lock_guard checkLock(notifyInstance.lock_); + auto& callbackMap = notifyInstance.servicePublishCallback_; + EXPECT_EQ(callbackMap.count(newPublishId), 0); + EXPECT_EQ(callbackMap.size(), (size_t)MAX_CONTAINER_SIZE); + } +} + +/** + * @tc.name: RegisterServicePublishCallback_004 + * @tc.desc: 重复注册同一publishId的回调（覆盖旧回调） + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DeviceManagerNotifyTest, RegisterServicePublishCallback_004, testing::ext::TestSize.Level0) +{ + int64_t testPublishId = 1003; + auto oldCallback = std::make_shared(); + auto newCallback = std::make_shared(); + + DeviceManagerNotify::GetInstance().RegisterServicePublishCallback(testPublishId, oldCallback); + DeviceManagerNotify::GetInstance().RegisterServicePublishCallback(testPublishId, newCallback); + + std::lock_guard autoLock(DeviceManagerNotify::GetInstance().lock_); + auto& callbackMap = DeviceManagerNotify::GetInstance().servicePublishCallback_; + + EXPECT_EQ(callbackMap.count(testPublishId), 1); + EXPECT_NE(callbackMap[testPublishId].get(), oldCallback.get()); + EXPECT_EQ(callbackMap[testPublishId].get(), newCallback.get()); +} + +/** + * @tc.name: OnServicePublishResult_001 + * @tc.desc: 回调存在且结果成功（DM_OK），验证正常调用 + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DeviceManagerNotifyTest, OnServicePublishResult_001, testing::ext::TestSize.Level0) +{ + auto& notify = DeviceManagerNotify::GetInstance(); + int64_t testPublishId = 1001; + auto testCallback = std::make_shared(); + notify.RegisterServicePublishCallback(testPublishId, testCallback); + int32_t testResult = 0; + notify.OnServicePublishResult(testPublishId, testResult); + std::lock_guard lock(testCallback->mtx); + EXPECT_EQ(testCallback->callCount, 1); + EXPECT_EQ(testCallback->lastPublishId, testPublishId); + EXPECT_EQ(testCallback->lastResult, testResult); + std::lock_guard notifyLock(notify.lock_); + EXPECT_EQ(notify.servicePublishCallback_.count(testPublishId), 1); +} + +/** + * @tc.name: OnServicePublishResult_002 + * @tc.desc: 回调存在且结果失败（非DM_OK），验证回调被删除 + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DeviceManagerNotifyTest, OnServicePublishResult_002, testing::ext::TestSize.Level0) +{ + auto& notify = DeviceManagerNotify::GetInstance(); + int64_t testPublishId = 1002; + auto testCallback = std::make_shared(); + notify.RegisterServicePublishCallback(testPublishId, testCallback); + int32_t testResult = 1; + notify.OnServicePublishResult(testPublishId, testResult); + std::lock_guard lock(testCallback->mtx); + EXPECT_EQ(testCallback->callCount, 1); + EXPECT_EQ(testCallback->lastPublishId, testPublishId); + EXPECT_EQ(testCallback->lastResult, testResult); + std::lock_guard notifyLock(notify.lock_); + EXPECT_EQ(notify.servicePublishCallback_.count(testPublishId), 0); +} + +/** + * @tc.name: OnServicePublishResult_003 + * @tc.desc: 回调未注册，验证错误处理 + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DeviceManagerNotifyTest, OnServicePublishResult_003, testing::ext::TestSize.Level0) +{ + auto& notify = DeviceManagerNotify::GetInstance(); + int64_t unregisteredId = 9999; + int32_t testResult = 0; + notify.OnServicePublishResult(unregisteredId, testResult); + SUCCEED(); +} + +/** + * @tc.name: OnServicePublishResult_004 + * @tc.desc: 回调已注册但为空指针，验证容错处理 + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DeviceManagerNotifyTest, OnServicePublishResult_004, testing::ext::TestSize.Level0) +{ + auto& notify = DeviceManagerNotify::GetInstance(); + int64_t testPublishId = 1004; + + std::lock_guard lock(notify.lock_); + notify.servicePublishCallback_[testPublishId] = nullptr; + int32_t testResult = 0; + notify.OnServicePublishResult(testPublishId, testResult); + + SUCCEED(); +} +} +} // namespace DistributedHardware +} // namespace OHOS \ No newline at end of file diff --git a/test/unittest/UTTest_device_manager_service.cpp b/test/unittest/UTTest_device_manager_service.cpp index 3496f2e2b..0cc19bb9d 100644 --- a/test/unittest/UTTest_device_manager_service.cpp +++ b/test/unittest/UTTest_device_manager_service.cpp @@ -14,6 +14,8 @@ */ #include "UTTest_device_manager_service.h" +#include +#include #include "accesstoken_kit.h" #include "dm_constants.h" @@ -71,7 +73,6 @@ void DeviceManagerServiceTest::TearDown() Mock::VerifyAndClearExpectations(multipleUserConnectorMock_.get()); Mock::VerifyAndClearExpectations(dMCommToolMock_.get()); Mock::VerifyAndClearExpectations(deviceProfileConnectorMock_.get()); - Mock::VerifyAndClearExpectations(deviceNameManagerMock_.get()); } void DeviceManagerServiceTest::SetUpTestCase() @@ -86,7 +87,6 @@ void DeviceManagerServiceTest::SetUpTestCase() DmMultipleUserConnector::dmMultipleUserConnector = multipleUserConnectorMock_; DmDMCommTool::dmDMCommTool = dMCommToolMock_; DmDeviceProfileConnector::dmDeviceProfileConnector = deviceProfileConnectorMock_; - DmDeviceNameManager::dmDeviceNameManager_ = deviceNameManagerMock_; } void DeviceManagerServiceTest::TearDownTestCase() @@ -111,8 +111,6 @@ void DeviceManagerServiceTest::TearDownTestCase() dMCommToolMock_ = nullptr; DmDeviceProfileConnector::dmDeviceProfileConnector = nullptr; deviceProfileConnectorMock_ = nullptr; - DmDeviceNameManager::dmDeviceNameManager_ = nullptr; - deviceNameManagerMock_ = nullptr; } namespace { @@ -2611,6 +2609,334 @@ HWTEST_F(DeviceManagerServiceTest, OpenAuthSessionWithPara_001, testing::ext::Te int32_t ret = DeviceManagerService::GetInstance().OpenAuthSessionWithPara(deviceId, actionId, isEnable160m); EXPECT_NE(ret, DM_OK); } + +HWTEST_F(DeviceManagerServiceTest, RegisterServiceInfo_001, testing::ext::TestSize.Level1) +{ + ServiceRegInfo serviceRegInfo; + serviceRegInfo.serviceInfo.serviceId = 12345; + serviceRegInfo.serviceInfo.serviceType = 1; + serviceRegInfo.serviceInfo.serviceName = "TestService"; + serviceRegInfo.serviceInfo.serviceDisplayName = "TestServiceDisplay"; + int32_t regServiceId = 0; + + EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true)); + EXPECT_CALL(*deviceManagerServiceImplMock_, GenerateRegServiceId(_)).WillOnce(Return(DM_OK)); + EXPECT_CALL(*deviceManagerServiceImplMock_, ConvertServiceInfoProfileByRegInfo(_, _)).WillOnce(Return(DM_OK)); + EXPECT_CALL(*deviceManagerServiceImplMock_, PutServiceInfoProfile(_)).Times(1); + + int32_t ret = DeviceManagerService::GetInstance().RegisterServiceInfo(serviceRegInfo, regServiceId); + EXPECT_EQ(ret, DM_OK); + EXPECT_NE(regServiceId, 0); +} + +HWTEST_F(DeviceManagerServiceTest, RegisterServiceInfo_002, testing::ext::TestSize.Level1) +{ + ServiceRegInfo serviceRegInfo; + int32_t regServiceId = 0; + + EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(false)); + + int32_t ret = DeviceManagerService::GetInstance().RegisterServiceInfo(serviceRegInfo, regServiceId); + EXPECT_EQ(ret, ERR_DM_NO_PERMISSION); +} + +HWTEST_F(DeviceManagerServiceTest, RegisterServiceInfo_003, testing::ext::TestSize.Level1) +{ + ServiceRegInfo serviceRegInfo; + int32_t regServiceId = 0; + + EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true)); + EXPECT_CALL(*deviceManagerServiceImplMock_, GenerateRegServiceId(_)).WillOnce(Return(ERR_DM_FAILED)); + + int32_t ret = DeviceManagerService::GetInstance().RegisterServiceInfo(serviceRegInfo, regServiceId); + EXPECT_EQ(ret, ERR_DM_FAILED); +} + +HWTEST_F(DeviceManagerServiceTest, RegisterServiceInfo_004, testing::ext::TestSize.Level1) +{ + ServiceRegInfo serviceRegInfo; + int32_t regServiceId = 0; + + EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true)); + EXPECT_CALL(*deviceManagerServiceImplMock_, GenerateRegServiceId(_)).WillOnce(Return(DM_OK)); + EXPECT_CALL(*deviceManagerServiceImplMock_, ConvertServiceInfoProfileByRegInfo(_, _)).WillOnce(Return(ERR_DM_FAILED)); + + int32_t ret = DeviceManagerService::GetInstance().RegisterServiceInfo(serviceRegInfo, regServiceId); + EXPECT_EQ(ret, ERR_DM_FAILED); +} + +HWTEST_F(DeviceManagerServiceTest, UnRegisterServiceInfo_001, testing::ext::TestSize.Level1) +{ + int32_t regServiceId = 12345; + + EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true)); + EXPECT_CALL(*multipleUserConnectorMock_, GetCallerUserId(_)).WillOnce(SetArgReferee<0>(100)); + EXPECT_CALL(*deviceProfileConnectorMock_, DeleteServiceInfoProfile(regServiceId)).Times(1); + + int32_t ret = DeviceManagerService::GetInstance().UnRegisterServiceInfo(regServiceId); + EXPECT_EQ(ret, DM_OK); +} + +HWTEST_F(DeviceManagerServiceTest, UnRegisterServiceInfo_002, testing::ext::TestSize.Level1) +{ + int32_t regServiceId = 12345; + + EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(false)); + + int32_t ret = DeviceManagerService::GetInstance().UnRegisterServiceInfo(regServiceId); + EXPECT_EQ(ret, ERR_DM_NO_PERMISSION); +} + +HWTEST_F(DeviceManagerServiceTest, StartPublishService_001, testing::ext::TestSize.Level1) +{ + std::string pkgName = ""; + PublishServiceParam param; + int64_t serviceId = 0; + + EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(false)); + + int32_t ret = DeviceManagerService::GetInstance().StartPublishService(pkgName, param, serviceId); + EXPECT_EQ(ret, ERR_DM_NO_PERMISSION); +} + +HWTEST_F(DeviceManagerServiceTest, StartPublishService_002, testing::ext::TestSize.Level1) +{ + std::string pkgName = "com.example.pkg"; + PublishServiceParam param; + int64_t serviceId = 0; + + EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(false)); + + int32_t ret = DeviceManagerService::GetInstance().StartPublishService(pkgName, param, serviceId); + EXPECT_EQ(ret, ERR_DM_NO_PERMISSION); +} + +HWTEST_F(DeviceManagerServiceTest, StartPublishService_003, testing::ext::TestSize.Level1) +{ + std::string pkgName = "com.example.pkg"; + PublishServiceParam param; + int64_t serviceId = 0; + + EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true)); + EXPECT_CALL(*deviceManagerServiceImplMock_, GenerateServiceId(_)).WillOnce(Return(ERR_DM_FAILED)); + + int32_t ret = DeviceManagerService::GetInstance().StartPublishService(pkgName, param, serviceId); + EXPECT_EQ(ret, ERR_DM_FAILED); +} + +HWTEST_F(DeviceManagerServiceTest, StartPublishService_004, testing::ext::TestSize.Level1) +{ + std::string pkgName = "com.example.pkg"; + PublishServiceParam param; + int64_t serviceId = 0; + + EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true)); + EXPECT_CALL(*deviceManagerServiceImplMock_, GenerateServiceId(_)).WillOnce(Return(DM_OK)); + EXPECT_CALL(*multipleUserConnectorMock_, GetCallerUserId(_)).WillOnce([](int32_t &userId) { userId = 100; }); + EXPECT_CALL(*deviceProfileConnectorMock_, PutServiceInfoProfile(_)).WillOnce(Return(ERR_DM_FAILED)); + + int32_t ret = DeviceManagerService::GetInstance().StartPublishService(pkgName, param, serviceId); + EXPECT_EQ(ret, ERR_DM_FAILED); +} + +HWTEST_F(DeviceManagerServiceTest, StartPublishService_005 , testing::ext::TestSize.Level1) +{ + std::string pkgName = "com.example.pkg"; + PublishServiceParam param; + param.serviceInfo.serviceId = 456; + param.serviceInfo.serviceType = 1; + param.serviceInfo.serviceName = "TestService"; + param.serviceInfo.serviceDisplayName = "TestDisplayName"; + int64_t serviceId = 0; + ProcessInfo expectedProcessInfo; + expectedProcessInfo.pkgName = pkgName; + expectedProcessInfo.userId = 100; + + EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true)); + EXPECT_CALL(*deviceManagerServiceImplMock_, GenerateServiceId(_)).WillOnce(Return(DM_OK)); + EXPECT_CALL(*multipleUserConnectorMock_, GetCallerUserId(_)).WillOnce([](int32_t &userId) { userId = 100; }); + EXPECT_CALL(*deviceProfileConnectorMock_, PutServiceInfoProfile(_)).WillOnce(Return(DM_OK)); + EXPECT_CALL(*deviceManagerServiceImplMock_, IsDMServiceAdapterResidentLoad()).WillOnce(Return(true)); + EXPECT_CALL(*deviceManagerServiceImplMock_, StartPublishService(_, _, _)).WillOnce(Return(DM_OK)); + + int32_t ret = DeviceManagerService::GetInstance().StartPublishService(pkgName, param, serviceId); + EXPECT_EQ(ret, DM_OK); + EXPECT_EQ(serviceId, param.serviceInfo.serviceId); +} + +HWTEST_F(DeviceManagerServiceTest, StopPublishService_001, testing::ext::TestSize.Level1) +{ + int64_t serviceId = 123456; + + EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(false)); + + int32_t ret = DeviceManagerService::GetInstance().StopPublishService(serviceId); + EXPECT_EQ(ret, ERR_DM_NO_PERMISSION); +} + +HWTEST_F(DeviceManagerServiceTest, StopPublishService_002, testing::ext::TestSize.Level1) +{ + int64_t serviceId = 123456; + + EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true)); + EXPECT_CALL(*deviceProfileConnectorMock_, GetServiceInfoProfileByServiceId(serviceId, _)).WillOnce(Return(ERR_DM_FAILED)); + + int32_t ret = DeviceManagerService::GetInstance().StopPublishService(serviceId); + EXPECT_EQ(ret, ERR_DM_FAILED); +} + +HWTEST_F(DeviceManagerServiceTest, StopPublishService_003, testing::ext::TestSize.Level1) +{ + int64_t serviceId = 123456; + ServiceInfoProfile serviceInfoProfile; + + EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true)); + EXPECT_CALL(*deviceProfileConnectorMock_, GetServiceInfoProfileByServiceId(serviceId, _)) + .WillOnce(DoAll(SetArgReferee<1>(serviceInfoProfile), Return(DM_OK))); + EXPECT_CALL(*deviceProfileConnectorMock_, PutServiceInfoProfile(_)).Times(1); + EXPECT_CALL(*deviceProfileConnectorMock_, GetAllAccessControlProfile()) + .WillOnce(Return(std::vector{})); + + EXPECT_CALL(*deviceManagerServiceImplMock_, IsDMServiceAdapterResidentLoad()).WillOnce(Return(false)); + + int32_t ret = DeviceManagerService::GetInstance().StopPublishService(serviceId); + EXPECT_EQ(ret, ERR_DM_UNSUPPORTED_METHOD); +} + +HWTEST_F(DeviceManagerServiceTest, StopPublishService_004, testing::ext::TestSize.Level1) +{ + int64_t serviceId = 123456; + ServiceInfoProfile serviceInfoProfile; + + EXPECT_CALL(*permissionManagerMock_, CheckPermission()).WillOnce(Return(true)); + EXPECT_CALL(*deviceProfileConnectorMock_, GetServiceInfoProfileByServiceId(serviceId, _)) + .WillOnce(DoAll(SetArgReferee<1>(serviceInfoProfile), Return(DM_OK))); + EXPECT_CALL(*deviceProfileConnectorMock_, PutServiceInfoProfile(_)).Times(1); + EXPECT_CALL(*deviceProfileConnectorMock_, GetAllAccessControlProfile()) + .WillOnce(Return(std::vector{})); + EXPECT_CALL(*deviceManagerServiceImplMock_, IsDMServiceAdapterResidentLoad()).WillOnce(Return(true)); + + EXPECT_CALL(*softbusListenerMock_, SendAclChangedBroadcast(_)).Times(1); + + int32_t ret = DeviceManagerService::GetInstance().StopPublishService(serviceId); + EXPECT_EQ(ret, DM_OK); +} + +HWTEST_F(DeviceManagerServiceTest, GenerateServiceId_001, testing::ext::TestSize.Level1) +{ + int64_t serviceId = 0; + EXPECT_CALL(*deviceManagerServiceImplMock_, GetServiceBindLocalInfo(_)).WillOnce(Return(DM_OK)); + EXPECT_CALL(*deviceProfileConnectorMock_, GetServiceInfoProfileByServiceId(_, _)) + .WillOnce(Return(ERR_DM_FAILED)); + int32_t ret = DeviceManagerService::GetInstance().GenerateServiceId(serviceId); + EXPECT_EQ(ret, DM_OK); +} + +HWTEST_F(DeviceManagerServiceTest, GenerateServiceId_002, testing::ext::TestSize.Level1) +{ + int64_t serviceId = 0; + EXPECT_CALL(*deviceManagerServiceImplMock_, GetServiceBindLocalInfo(_)).WillOnce(Return(ERR_DM_FAILED)); + int32_t ret = DeviceManagerService::GetInstance().GenerateServiceId(serviceId); + EXPECT_EQ(ret, ERR_DM_FAILED); +} + +HWTEST_F(DeviceManagerServiceTest, GenerateServiceId_003, testing::ext::TestSize.Level1) +{ + int64_t serviceId = 0; + EXPECT_CALL(*deviceManagerServiceImplMock_, GetServiceBindLocalInfo(_)).WillOnce(Return(DM_OK)); + EXPECT_CALL(*deviceProfileConnectorMock_, GetServiceInfoProfileByServiceId(_, _)) + .Times(3) + .WillRepeatedly(Return(DM_OK)); + int32_t ret = DeviceManagerService::GetInstance().GenerateServiceId(serviceId); + EXPECT_EQ(ret, ERR_DM_FAILED); +} + +HWTEST_F(DeviceManagerServiceTest, GetServiceBindLocalInfo_001, testing::ext::TestSize.Level1) +{ + ServiceBindLocalInfo localInfo; + int32_t ret = DeviceManagerService::GetInstance().GetServiceBindLocalInfo(localInfo); + EXPECT_EQ(ret, DM_OK); + EXPECT_FALSE(localInfo.localUdid.empty()); + EXPECT_EQ(localInfo.tokenId, OHOS::IPCSkeleton::GetCallingTokenID()); +} + +HWTEST_F(DeviceManagerServiceTest, CreateServiceInfoProfile_001, testing::ext::TestSize.Level1) +{ + PublishServiceParam param; + param.regServiceId = 123; + param.serviceInfo.serviceId = 456; + param.serviceInfo.serviceType = 1; + param.serviceInfo.serviceName = "TestService"; + param.serviceInfo.serviceDisplayName = "TestDisplayName"; + int32_t userId = 100; + + ServiceInfoProfile profile = DeviceManagerService::GetInstance().CreateServiceInfoProfile(param, userId); + + EXPECT_EQ(profile.regServiceId, 123); + EXPECT_EQ(profile.deviceId, "device123"); + EXPECT_EQ(profile.userId, 100); + EXPECT_EQ(profile.tokenId, OHOS::IPCSkeleton::GetCallingTokenID()); + EXPECT_EQ(profile.publishState, 1); + EXPECT_EQ(profile.serviceId, 456); + EXPECT_EQ(profile.serviceType, std::to_string(1)); + EXPECT_EQ(profile.serviceName, "TestService"); + EXPECT_EQ(profile.serviceDisplayName, "TestDisplayName"); +} + +HWTEST_F(DeviceManagerServiceTest, ConvertServiceInfoProfileByRegInfo_001, testing::ext::TestSize.Level1) +{ + ServiceRegInfo regInfo; + regInfo.serviceInfo.serviceId = 123; + regInfo.serviceInfo.serviceType = 1; + regInfo.serviceInfo.serviceName = "TestService"; + regInfo.serviceInfo.serviceDisplayName = "TestDisplayName"; + ServiceInfoProfile profile; + + int32_t ret = DeviceManagerService::GetInstance().ConvertServiceInfoProfileByRegInfo(regInfo, profile); + EXPECT_EQ(ret, DM_OK); + + EXPECT_EQ(profile.serviceId, 123); + EXPECT_EQ(profile.serviceType, std::to_string(1)); + EXPECT_EQ(profile.serviceName, "TestService"); + EXPECT_EQ(profile.serviceDisplayName, "TestDisplayName"); + EXPECT_FALSE(profile.deviceId.empty()); + EXPECT_GT(profile.userId, 0); + EXPECT_EQ(profile.tokenId, OHOS::IPCSkeleton::GetCallingTokenID()); +} + +HWTEST_F(DeviceManagerServiceTest, ConvertServiceInfoProfileByRegInfo_002, testing::ext::TestSize.Level1) +{ + + ServiceRegInfo regInfo; + ServiceInfoProfile profile; + + EXPECT_CALL(*deviceManagerServiceImplMock_, GetServiceBindLocalInfo(_)).WillOnce(Return(ERR_DM_FAILED)); + int32_t ret = DeviceManagerService::GetInstance().ConvertServiceInfoProfileByRegInfo(regInfo, profile); + EXPECT_EQ(ret, ERR_DM_FAILED); +} + +HWTEST_F(DeviceManagerServiceTest, GenerateRegServiceId_001, testing::ext::TestSize.Level1) +{ + + int32_t regServiceId = 0; + + EXPECT_CALL(*cryptoMock_, RAND_bytes(_, sizeof(int32_t))).WillOnce(Return(1)); + int32_t ret = DeviceManagerService::GetInstance().GenerateRegServiceId(regServiceId); + EXPECT_EQ(ret, DM_OK); + + EXPECT_NE(regServiceId, 0); +} + +HWTEST_F(DeviceManagerServiceTest, GenerateRegServiceId_002, testing::ext::TestSize.Level1) +{ + + int32_t regServiceId = 0; + EXPECT_CALL(*cryptoMock_, RAND_bytes(_, sizeof(int32_t))).WillOnce(Return(0)); + int32_t ret = DeviceManagerService::GetInstance().GenerateRegServiceId(regServiceId); + EXPECT_EQ(ret, ERR_DM_FAILED); +} + } // namespace } // namespace DistributedHardware } // namespace OHOS + diff --git a/test/unittest/UTTest_device_manager_service_impl.cpp b/test/unittest/UTTest_device_manager_service_impl.cpp index e44d72c59..f4497196e 100644 --- a/test/unittest/UTTest_device_manager_service_impl.cpp +++ b/test/unittest/UTTest_device_manager_service_impl.cpp @@ -1636,9 +1636,8 @@ HWTEST_F(DeviceManagerServiceImplTest, StopAuthenticateDevice_102, testing::ext: if (deviceManagerServiceImpl_->authMgr_ == nullptr) { deviceManagerServiceImpl_->Initialize(listener_); } - deviceManagerServiceImpl_->tokenIdSessionIdMap_.clear(); int ret = deviceManagerServiceImpl_->StopAuthenticateDevice(pkgName); - EXPECT_EQ(ret, DM_OK); + EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); } HWTEST_F(DeviceManagerServiceImplTest, CheckIsSameAccount_001, testing::ext::TestSize.Level1) @@ -2107,99 +2106,62 @@ HWTEST_F(DeviceManagerServiceImplTest, InitNewProtocolAuthMgr_001, testing::ext: bool isSrcSide = true; uint64_t tokenId = 1000023; uint64_t logicalSessionId = 456789; - int sessionId = 1; const std::string pkgName = "InitNewProtocolAuthMgr"; - deviceManagerServiceImpl_->authMgrMap_.clear(); - int32_t ret = deviceManagerServiceImpl_->InitNewProtocolAuthMgr(isSrcSide, tokenId, logicalSessionId, pkgName, - sessionId); + int32_t ret = deviceManagerServiceImpl_->InitNewProtocolAuthMgr(isSrcSide, tokenId, logicalSessionId, pkgName); EXPECT_EQ(ret, DM_OK); - deviceManagerServiceImpl_->authMgrMap_.clear(); isSrcSide = false; - ret = deviceManagerServiceImpl_->InitNewProtocolAuthMgr(isSrcSide, tokenId, logicalSessionId, pkgName, sessionId); + ret = deviceManagerServiceImpl_->InitNewProtocolAuthMgr(isSrcSide, tokenId, logicalSessionId, pkgName); EXPECT_EQ(ret, DM_OK); - deviceManagerServiceImpl_->authMgrMap_.clear(); } HWTEST_F(DeviceManagerServiceImplTest, InitOldProtocolAuthMgr_001, testing::ext::TestSize.Level1) { uint64_t tokenId = 100002311; - int sessionId = 1; const std::string pkgName = "InitOldProtocolAuthMgr"; - deviceManagerServiceImpl_->authMgrMap_.clear(); - int32_t ret = deviceManagerServiceImpl_->InitOldProtocolAuthMgr(tokenId, pkgName, sessionId); + int32_t ret = deviceManagerServiceImpl_->InitOldProtocolAuthMgr(tokenId, pkgName); EXPECT_EQ(ret, DM_OK); - deviceManagerServiceImpl_->authMgrMap_.clear(); deviceManagerServiceImpl_->authMgr_ = nullptr; - ret = deviceManagerServiceImpl_->InitOldProtocolAuthMgr(tokenId, pkgName, sessionId); + ret = deviceManagerServiceImpl_->InitOldProtocolAuthMgr(tokenId, pkgName); EXPECT_EQ(ret, DM_OK); - deviceManagerServiceImpl_->authMgrMap_.clear(); -} - -HWTEST_F(DeviceManagerServiceImplTest, CleanSessionMap_001, testing::ext::TestSize.Level1) -{ - int sessionId = 0; - std::string deviceId = "deviceId"; - deviceManagerServiceImpl_->CleanSessionMap(nullptr); - std::shared_ptr session = std::make_shared(sessionId, deviceId); - session->logicalSessionCnt_.fetch_add(1); - deviceManagerServiceImpl_->CleanSessionMap(session); - EXPECT_EQ(session->logicalSessionCnt_.load(), 0); } -HWTEST_F(DeviceManagerServiceImplTest, CleanSessionMap_002, testing::ext::TestSize.Level1) -{ - int sessionId = 0; - deviceManagerServiceImpl_->softbusConnector_ = nullptr; - deviceManagerServiceImpl_->CleanSessionMap(sessionId); - if (deviceManagerServiceImpl_->softbusConnector_ == nullptr) { - deviceManagerServiceImpl_->Initialize(listener_); - } - deviceManagerServiceImpl_->sessionsMap_.clear(); - deviceManagerServiceImpl_->CleanSessionMap(sessionId); - std::string deviceId = "deviceId"; - std::shared_ptr session = std::make_shared(sessionId, deviceId); - deviceManagerServiceImpl_->sessionsMap_[sessionId] = session; - deviceManagerServiceImpl_->CleanSessionMap(sessionId); - EXPECT_TRUE(deviceManagerServiceImpl_->sessionsMap_.empty()); -} - -HWTEST_F(DeviceManagerServiceImplTest, AddAuthMgr_001, testing::ext::TestSize.Level1) -{ - uint64_t tokenId = 0; - int sessionId = 1; - deviceManagerServiceImpl_->authMgrMap_.clear(); - deviceManagerServiceImpl_->AddAuthMgr(tokenId, sessionId, nullptr); - EXPECT_TRUE(deviceManagerServiceImpl_->authMgrMap_.empty()); - - if (deviceManagerServiceImpl_->softbusConnector_ == nullptr) { - deviceManagerServiceImpl_->Initialize(listener_); - } - std::shared_ptr authMgr = std::make_shared( - deviceManagerServiceImpl_->softbusConnector_, deviceManagerServiceImpl_->hiChainConnector_, - deviceManagerServiceImpl_->listener_, deviceManagerServiceImpl_->hiChainAuthConnector_); - deviceManagerServiceImpl_->sessionEnableMap_[sessionId] = false; - deviceManagerServiceImpl_->AddAuthMgr(tokenId, sessionId, authMgr); - EXPECT_TRUE(deviceManagerServiceImpl_->authMgrMap_.empty()); - - deviceManagerServiceImpl_->sessionEnableMap_.clear(); - deviceManagerServiceImpl_->AddAuthMgr(tokenId, sessionId, authMgr); - EXPECT_FALSE(deviceManagerServiceImpl_->authMgrMap_.empty()); - deviceManagerServiceImpl_->sessionEnableMap_.clear(); - deviceManagerServiceImpl_->authMgrMap_.clear(); -} - -HWTEST_F(DeviceManagerServiceImplTest, EraseAuthMgr_001, testing::ext::TestSize.Level1) -{ - uint64_t tokenId = 0; - std::shared_ptr authMgr = std::make_shared( - deviceManagerServiceImpl_->softbusConnector_, deviceManagerServiceImpl_->hiChainConnector_, - deviceManagerServiceImpl_->listener_, deviceManagerServiceImpl_->hiChainAuthConnector_); - deviceManagerServiceImpl_->authMgrMap_[tokenId] = authMgr; - deviceManagerServiceImpl_->EraseAuthMgr(tokenId); - EXPECT_TRUE(deviceManagerServiceImpl_->authMgrMap_.find(tokenId) == deviceManagerServiceImpl_->authMgrMap_.end()); -} +// HWTEST_F(DeviceManagerServiceImplTest, HandleStopPublishService_001, testing::ext::TestSize.Level1) { +// int64_t serviceId = 123456; +// ServiceInfoProfile serviceInfoProfile; +// serviceInfoProfile.publishState = 1; + +// EXPECT_CALL(*deviceProfileConnectorMock_, GetServiceInfoProfileByServiceId(serviceId, _)) +// .WillOnce(DoAll(SetArgReferee<1>(serviceInfoProfile), Return(DM_OK))); +// EXPECT_CALL(*deviceProfileConnectorMock_, PutServiceInfoProfile(_)).Times(1); + +// std::vector profiles; +// AccessControlProfile profile; +// JsonObject extraData; +// extraData[SERVICE_ID_KEY] = serviceId; +// profile.SetExtraData(extraData.Dump()); +// profiles.push_back(profile); +// EXPECT_CALL(*deviceProfileConnectorMock_, GetAllAccessControlProfile()) +// .WillOnce(Return(profiles)); +// EXPECT_CALL(*deviceProfileConnectorMock_, UpdateAccessControlProfile(_)).Times(1); + +// deviceManagerServiceImpl_->HandleStopPublishService(serviceId); + +// EXPECT_EQ(serviceInfoProfile.publishState, PUBLISH_STATE_UNPUBLISHED); +// } + +// HWTEST_F(DeviceManagerServiceImplTest, HandleStopPublishService_002, testing::ext::TestSize.Level1) { +// int64_t serviceId = 654321; + +// EXPECT_CALL(*deviceProfileConnectorMock_, GetServiceInfoProfileByServiceId(serviceId, _)) +// .WillOnce(Return(ERR_DM_FAILED)); +// EXPECT_CALL(*deviceProfileConnectorMock_, PutServiceInfoProfile(_)).Times(0); +// EXPECT_CALL(*deviceProfileConnectorMock_, GetAllAccessControlProfile()).Times(0); +// EXPECT_CALL(*deviceProfileConnectorMock_, UpdateAccessControlProfile(_)).Times(0); + +// deviceManagerServiceImpl_->HandleStopPublishService(serviceId); +// } } // namespace } // namespace DistributedHardware } // namespace OHOS diff --git a/test/unittest/UTTest_device_manager_service_listener.cpp b/test/unittest/UTTest_device_manager_service_listener.cpp index ff761bb53..86b27491c 100644 --- a/test/unittest/UTTest_device_manager_service_listener.cpp +++ b/test/unittest/UTTest_device_manager_service_listener.cpp @@ -17,6 +17,7 @@ #include #include +#include "ipc_server_listener_mock.h" #include "dm_anonymous.h" #include "dm_constants.h" @@ -29,6 +30,7 @@ #include "ipc_notify_publish_result_req.h" #include "device_manager_service_notify.h" #include "app_manager.h" +#include "ipc_service_publish_result_req.h" using namespace testing; using namespace testing::ext; @@ -1103,6 +1105,49 @@ HWTEST_F(DeviceManagerServiceListenerTest, OpenAuthSessionWithPara_001, testing: int32_t ret = listener_->OpenAuthSessionWithPara(deviceId, actionId, isEnable160m); EXPECT_NE(ret, DM_OK); } + +HWTEST_F(DeviceManagerServiceListenerTest, OnServicePublishResult_001, testing::ext::TestSize.Level1) +{ + std::shared_ptr listener_ = std::make_shared(); + ProcessInfo processInfo; + processInfo.userId = 100; + processInfo.pkgName = "com.ohos.helloworldkl"; + int64_t serviceId = 123456789; + int32_t publishResult = DM_OK; + + std::vector processInfos; + processInfos.push_back(processInfo); + std::set systemSA; + systemSA.insert("pkgName"); + + EXPECT_CALL(*ipcServerListenerMock_, GetAllProcessInfo()).WillOnce(Return(processInfos)); + EXPECT_CALL(*ipcServerListenerMock_, GetSystemSA()).WillOnce(Return(systemSA)); + + listener_->OnServicePublishResult(processInfo, serviceId, publishResult); +} + +HWTEST_F(DeviceManagerServiceListenerTest, OnServicePublishResult_002, testing::ext::TestSize.Level1) +{ + std::shared_ptr listener_ = std::make_shared(); + ProcessInfo processInfo; + processInfo.userId = 0; + processInfo.pkgName = ""; + int64_t serviceId = 0; + int32_t publishResult = DM_OK; + + std::vector processInfos; + processInfos.push_back(processInfo); + std::set systemSA; + systemSA.insert("pkgName"); + EXPECT_CALL(*ipcServerListenerMock_, GetAllProcessInfo()).WillOnce(Return(processInfos)); + EXPECT_CALL(*ipcServerListenerMock_, GetSystemSA()).WillOnce(Return(systemSA)); + + listener_->OnServicePublishResult(processInfo, serviceId, publishResult); +} + + + + } // namespace } // namespace DistributedHardware } // namespace OHOS diff --git a/test/unittest/UTTest_device_manager_utils.cpp b/test/unittest/UTTest_device_manager_utils.cpp new file mode 100644 index 000000000..0b554f6a9 --- /dev/null +++ b/test/unittest/UTTest_device_manager_utils.cpp @@ -0,0 +1,113 @@ +/* + * 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 + * + * 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 "UTTest_device_manager_utils.h" + +#include "common_event_support.h" +#include "dm_account_common_event.h" +#include "dm_constants.h" +#include "matching_skills.h" +#include "system_ability_definition.h" + +namespace OHOS { +namespace DistributedHardware { +std::unordered_map> g_servicePublishCallbackMap; +std::mutex g_servicePublishCallbackMapMutex; +void DeviceManagerUtilsTest::SetUp() +{ + std::lock_guard lock{g_servicePublishCallbackMapMutex}; + g_servicePublishCallbackMap.clear(); + impl.bundleName_ = testBundleName; +} + +void DeviceManagerUtilsTest::TearDown() +{ + std::lock_guard lock{g_servicePublishCallbackMapMutex}; + g_servicePublishCallbackMap.clear(); +} + +void DeviceManagerUtilsTest::SetUpTestCase() +{ +} + +void DeviceManagerUtilsTest::TearDownTestCase() +{ +} + +void AccountCommonEventCallbacks(const std::string commonEventType, int32_t currentUserId, int32_t beforeUserId) +{ +} +namespace { + std::unordered_map> g_servicePublishCallbackMap; + std::mutex g_servicePublishCallbackMapMutex; + +/** + * @tc.name: OnServicePublishResult_001 + * @tc.desc: + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DeviceManagerUtilsTest, OnServicePublishResult_001, testing::ext::TestSize.Level1) +{ + int result = impl.ReleaseServicePublishCallback(); + + EXPECT_EQ(result, ERR_OK); + std::lock_guard lock(g_servicePublishCallbackMapMutex); + EXPECT_EQ(g_servicePublishCallbackMap.find(testBundleName), g_servicePublishCallbackMap.end()); +} + +/** + * @tc.name: OnServicePublishResult_002 + * @tc.desc: + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DeviceManagerUtilsTest, OnServicePublishResult_002, testing::ext::TestSize.Level1) +{ + auto testCallback = std::make_shared(2); + { + std::lock_guard lock(g_servicePublishCallbackMapMutex); + g_servicePublishCallbackMap[testBundleName] = testCallback; + } + int result = impl.ReleaseServicePublishCallback(); + + EXPECT_EQ(result, ERR_OK); + EXPECT_EQ(testCallback->GetRefCount(), 1); + std::lock_guard lock(g_servicePublishCallbackMapMutex); + EXPECT_NE(g_servicePublishCallbackMap.find(testBundleName), g_servicePublishCallbackMap.end()); +} + +/** + * @tc.name: OnServicePublishResult_003 + * @tc.desc: + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DeviceManagerUtilsTest, OnServicePublishResult_003, testing::ext::TestSize.Level1) +{ + auto testCallback = std::make_shared(1); + { + std::lock_guard lock(g_servicePublishCallbackMapMutex); + g_servicePublishCallbackMap[testBundleName] = testCallback; + } + int result = impl.ReleaseServicePublishCallback(); + + EXPECT_EQ(result, ERR_OK); + EXPECT_EQ(testCallback->GetRefCount(), 0); + std::lock_guard lock(g_servicePublishCallbackMapMutex); + EXPECT_EQ(g_servicePublishCallbackMap.find(testBundleName), g_servicePublishCallbackMap.end()); +} +} +} // namespace DistributedHardware +} // namespace OHOS \ No newline at end of file diff --git a/test/unittest/UTTest_device_manager_utils.h b/test/unittest/UTTest_device_manager_utils.h new file mode 100644 index 000000000..56b10f750 --- /dev/null +++ b/test/unittest/UTTest_device_manager_utils.h @@ -0,0 +1,76 @@ +/* + * Copyright (c) 2024 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_DEVICE_MANAGER_UTILS_TEST_H +#define OHOS_DEVICE_MANAGER_UTILS_TEST_H + +#include +#include +#include + +#include "common_event_support.h" +#include "app_manager_mock.h" +#include "multiple_user_connector_mock.h" +#include "deviceprofile_connector_mock.h" + +#include +#include + +#include "../../interfaces/cj/kits/include/device_manager_impl.h" + +namespace OHOS { +namespace DistributedHardware { +extern std::unordered_map> g_servicePublishCallbackMap; +extern std::mutex g_servicePublishCallbackMapMutex; + +class DeviceManagerUtilsTest : public testing::Test { +public: + DeviceManagerFfiImpl impl; + int32_t errCode; + std::string testBundleName = "com.example.testbundle"; + DeviceManagerUtilsTest() : impl(testBundleName, &errCode), testBundleName("com.example.testbundle") {} + static void SetUpTestCase(); + static void TearDownTestCase(); + static void SetUpTestSuite() + { + } + static void TearDownTestSuite() + { + } + void SetUp(); + void TearDown(); +}; + +class TestDmFfiServicePublishCallback : public DmFfiServicePublishCallback { +public: + int refCount; + std::string testBundleName = "com.example.testbundle"; + explicit TestDmFfiServicePublishCallback(int initialCount) + : DmFfiServicePublishCallback(testBundleName), refCount(initialCount) + { + } + void DecreaseRefCount() + { + refCount--; + } + int GetRefCount() + { + return refCount; + } +}; +} // namespace DistributedHardware +} // namespace OHOS + +#endif // OHOS_IPC_CLIENT_MANAGER_TEST_H \ No newline at end of file diff --git a/test/unittest/UTTest_dm_pin_holder.cpp b/test/unittest/UTTest_dm_pin_holder.cpp index ebeb19395..53b58d4c1 100644 --- a/test/unittest/UTTest_dm_pin_holder.cpp +++ b/test/unittest/UTTest_dm_pin_holder.cpp @@ -159,7 +159,8 @@ HWTEST_F(DmPinHolderTest, RegisterPinHolderCallback_101, testing::ext::TestSize. HWTEST_F(DmPinHolderTest, RegisterPinHolderCallback_102, testing::ext::TestSize.Level1) { std::string packName = "com.ohos.dmtest"; - std::shared_ptr listener = std::make_shared(); + auto listener = std::shared_ptr( + new IDeviceManagerServiceListenerTest()); std::shared_ptr pinHolder = std::make_shared(listener); pinHolder->session_ = nullptr; int32_t ret = pinHolder->RegisterPinHolderCallback(packName); diff --git a/test/unittest/UTTest_dm_pin_holder.h b/test/unittest/UTTest_dm_pin_holder.h index 4dfb660f8..d16d86c2f 100644 --- a/test/unittest/UTTest_dm_pin_holder.h +++ b/test/unittest/UTTest_dm_pin_holder.h @@ -57,6 +57,7 @@ public: class IDeviceManagerServiceListenerTest : public IDeviceManagerServiceListener { public: + IDeviceManagerServiceListenerTest() = default; virtual ~IDeviceManagerServiceListenerTest() { } @@ -273,6 +274,15 @@ public: (void)isEnable160m; return 0; } + + void OnServicePublishResult(const ProcessInfo &processInfo, int64_t serviceId, int32_t publishResult) + { + (void)processInfo; + (void)serviceId; + (void)publishResult; + return; + } + }; } // namespace DistributedHardware } // namespace OHOS diff --git a/test/unittest/UTTest_ipc_cmd_parser_service.cpp b/test/unittest/UTTest_ipc_cmd_parser_service.cpp index 21cc9a364..80ae770fd 100644 --- a/test/unittest/UTTest_ipc_cmd_parser_service.cpp +++ b/test/unittest/UTTest_ipc_cmd_parser_service.cpp @@ -50,6 +50,13 @@ #include "ipc_set_useroperation_req.h" #include "ipc_unauthenticate_device_req.h" #include "ipc_unpublish_req.h" +#include "ipc_start_publish_service_req.h" +#include "ipc_publish_service_info_rsp.h" +#include "ipc_stop_publish_service_req.h" +#include "ipc_register_service_info_new_req.h" +#include "ipc_unregister_service_info_req.h" +#include "ipc_service_publish_result_req.h" + #include "json_object.h" namespace OHOS { @@ -1595,6 +1602,480 @@ HWTEST_F(IpcCmdParserServiceTest, ReadResponseFunc_030, testing::ext::TestSize.L int32_t cmdCode = SERVICE_CREDENTIAL_AUTH_STATUS_NOTIFY; ASSERT_EQ(ERR_DM_FAILED, TestReadResponseRspNull(cmdCode)); } + + +HWTEST_F(IpcCmdParserServiceTest, OnIpcCmdFunc_056, testing::ext::TestSize.Level0) +{ + int32_t cmdCode = BIND_TARGET_RESULT; + int32_t ret = ERR_DM_UNSUPPORTED_IPC_COMMAND; + MessageParcel data; + MessageParcel reply; + + std::string pkgName = "ohos.dm.test.bind"; + PeerTargetId targetId; + targetId.deviceId = "device_123"; + targetId.brMac = "br_mac_456"; + targetId.bleMac = "ble_mac_789"; + targetId.wifiIp = "192.168.1.1"; + targetId.wifiPort = 8080; + int32_t result = 0; + int32_t status = 1; + std::string content = "bind_success"; + + data.WriteString(pkgName); + EncodePeerTargetId(targetId, data); + data.WriteInt32(result); + data.WriteInt32(status); + data.WriteString(content); + + OnIpcCmdFunc ptr = GetIpcCmdFunc(cmdCode); + if (ptr) { + ret = ptr(data, reply); + } + + ASSERT_EQ(ret, DM_OK); + int32_t replyCode = reply.ReadInt32(); + ASSERT_EQ(replyCode, DM_OK); +} + +HWTEST_F(IpcCmdParserServiceTest, SetIpcRequestFunc_023, testing::ext::TestSize.Level0) +{ + int32_t cmdCode = START_PUBLISH_SERVICE; + MessageParcel data; + std::shared_ptr req = nullptr; + int ret = ERR_DM_UNSUPPORTED_IPC_COMMAND; + SetIpcRequestFunc ptr = GetIpcRequestFunc(cmdCode); + if (ptr) { + ret = ptr(req, data); + } + ASSERT_EQ(ret, ERR_DM_FAILED); +} + +HWTEST_F(IpcCmdParserServiceTest, SetIpcRequestFunc_024, testing::ext::TestSize.Level0) +{ + int32_t cmdCode = START_PUBLISH_SERVICE; + MessageParcel data; + std::shared_ptr req = nullptr; + int ret = ERR_DM_UNSUPPORTED_IPC_COMMAND; + SetIpcRequestFunc ptr = GetIpcRequestFunc(cmdCode); + + req = std::make_shared(); + std::shared_ptr startPublishReq = std::static_pointer_cast(req); + PublishServiceParam testParam; + testParam.regServiceId = 1; + startPublishReq->SetPublishServiceParam(testParam); + int64_t testServiceId = 1001; + startPublishReq->SetServiceId(testServiceId); + DmDiscoverMode testMode = DM_DISCOVER_MODE_ACTIVE; + + if (ptr) { + ret = ptr(req, data); + } + ASSERT_EQ(ret, DM_OK); +} + +HWTEST_F(IpcCmdParserServiceTest, SetIpcRequestFunc_025, testing::ext::TestSize.Level0) +{ + int32_t cmdCode = START_PUBLISH_SERVICE; + MessageParcel data; + std::shared_ptr req = nullptr; + int ret = ERR_DM_UNSUPPORTED_IPC_COMMAND; + + req = std::make_shared(); + std::shared_ptr startPublishReq = + std::static_pointer_cast(req); + + SetIpcRequestFunc ptr = GetIpcRequestFunc(cmdCode); + PublishServiceParam readParam; + data.ReadRawData(sizeof(PublishServiceParam)); + PublishServiceParam testParam; + testParam.regServiceId = 1; + ASSERT_EQ(readParam.regServiceId, testParam.regServiceId); + + int64_t readServiceId = data.ReadInt64(); + int64_t testServiceId = 1001; + ASSERT_EQ(readServiceId, testServiceId); + + int32_t readMode = data.ReadInt32(); + DmDiscoverMode testMode = DM_DISCOVER_MODE_ACTIVE; + ASSERT_EQ(readMode, static_cast(testMode)); +} + +HWTEST_F(IpcCmdParserServiceTest, ReadResponseFunc_031, testing::ext::TestSize.Level0) +{ + int32_t cmdCode = START_PUBLISH_SERVICE; + + int retNull = TestReadResponseRspNull(cmdCode); + ASSERT_EQ(retNull, ERR_DM_FAILED); +} + +HWTEST_F(IpcCmdParserServiceTest, ReadResponseFunc_032, testing::ext::TestSize.Level0) +{ + int32_t cmdCode = START_PUBLISH_SERVICE; + + int retNotNull = TestReadResponseRspNotNull(cmdCode); + ASSERT_EQ(retNotNull, DM_OK); +} + +HWTEST_F(IpcCmdParserServiceTest, ReadResponseFunc_033, testing::ext::TestSize.Level0) +{ + int32_t cmdCode = START_PUBLISH_SERVICE; + + MessageParcel reply; + auto rsp = std::make_shared(); + int32_t expectedErrCode = 123; + int64_t expectedServiceId = 456; + reply.WriteInt32(expectedErrCode); + reply.WriteInt64(expectedServiceId); + + ReadResponseFunc ptr = GetResponseFunc(cmdCode); + int retNotNull = ERR_DM_UNSUPPORTED_IPC_COMMAND; + if (ptr) { + retNotNull = ptr(reply, rsp); + } + ASSERT_EQ(retNotNull, DM_OK); + ASSERT_EQ(rsp->GetErrCode(), expectedErrCode); + ASSERT_EQ(rsp->GetServiceId(), expectedServiceId); +} + +HWTEST_F(IpcCmdParserServiceTest, SetIpcRequestFunc_026, testing::ext::TestSize.Level0) +{ + int32_t cmdCode = STOP_PUBLISH_SERVICE; + MessageParcel data; + std::shared_ptr req = nullptr; + int ret = ERR_DM_UNSUPPORTED_IPC_COMMAND; + + SetIpcRequestFunc ptr = GetIpcRequestFunc(cmdCode); + if (ptr) { + ret = ptr(req, data); + } + ASSERT_EQ(ret, ERR_DM_FAILED); +} + +HWTEST_F(IpcCmdParserServiceTest, SetIpcRequestFunc_027, testing::ext::TestSize.Level0) +{ + int32_t cmdCode = STOP_PUBLISH_SERVICE; + MessageParcel data; + std::shared_ptr req = nullptr; + int ret = ERR_DM_UNSUPPORTED_IPC_COMMAND; + + req = std::make_shared(); + std::shared_ptr stopPublishReq = + std::static_pointer_cast(req); + int64_t testServiceId = 2002; + stopPublishReq->SetServiceId(testServiceId); + + SetIpcRequestFunc ptr = GetIpcRequestFunc(cmdCode); + if (ptr) { + ret = ptr(req, data); + } + ASSERT_EQ(ret, DM_OK); +} + +HWTEST_F(IpcCmdParserServiceTest, SetIpcRequestFunc_028, testing::ext::TestSize.Level0) +{ + int32_t cmdCode = STOP_PUBLISH_SERVICE; + MessageParcel data; + std::shared_ptr req = nullptr; + int ret = ERR_DM_UNSUPPORTED_IPC_COMMAND; + int64_t testServiceId = 2002; + int64_t readServiceId = data.ReadInt64(); + ASSERT_EQ(readServiceId, testServiceId); +} + +HWTEST_F(IpcCmdParserServiceTest, ReadResponseFunc_034, testing::ext::TestSize.Level0) +{ + int32_t cmdCode = STOP_PUBLISH_SERVICE; + + MessageParcel emptyReply; + std::shared_ptr nullRsp = nullptr; + ReadResponseFunc nullPtr = GetResponseFunc(cmdCode); + int retNull = ERR_DM_UNSUPPORTED_IPC_COMMAND; + if (nullPtr) { + retNull = nullPtr(emptyReply, nullRsp); + } + ASSERT_EQ(retNull, ERR_DM_FAILED); +} + +HWTEST_F(IpcCmdParserServiceTest, ReadResponseFunc_035, testing::ext::TestSize.Level0) +{ + int32_t cmdCode = STOP_PUBLISH_SERVICE; + MessageParcel validReply; + std::shared_ptr validRsp = std::make_shared(); + int32_t expectedErrCode = 0; + validReply.WriteInt32(expectedErrCode); + + ReadResponseFunc validPtr = GetResponseFunc(cmdCode); + int retValid = ERR_DM_UNSUPPORTED_IPC_COMMAND; + if (validPtr) { + retValid = validPtr(validReply, validRsp); + } + ASSERT_EQ(retValid, DM_OK); + ASSERT_EQ(validRsp->GetErrCode(), expectedErrCode); +} + +HWTEST_F(IpcCmdParserServiceTest, SetIpcRequestFunc_029, testing::ext::TestSize.Level0) +{ + int32_t cmdCode = REGISTER_SERVICE_INFO; + MessageParcel data; + std::shared_ptr req = nullptr; + int ret = ERR_DM_UNSUPPORTED_IPC_COMMAND; + + SetIpcRequestFunc ptr = GetIpcRequestFunc(cmdCode); + if (ptr) { + ret = ptr(req, data); + } + ASSERT_EQ(ret, ERR_DM_FAILED); +} + +HWTEST_F(IpcCmdParserServiceTest, SetIpcRequestFunc_030, testing::ext::TestSize.Level0) +{ + int32_t cmdCode = REGISTER_SERVICE_INFO; + MessageParcel data; + std::shared_ptr req = nullptr; + int ret = ERR_DM_UNSUPPORTED_IPC_COMMAND; + + req = std::make_shared(); + std::shared_ptr regReq = + std::static_pointer_cast(req); + ServiceRegInfo testRegInfo; + testRegInfo.dataLen = 3; + testRegInfo.customData = "test_register_service"; + regReq->SetServiceRegInfo(testRegInfo); + int32_t testRegServiceId = 3003; + regReq->SetRegServiceId(testRegServiceId); + + SetIpcRequestFunc ptr = GetIpcRequestFunc(cmdCode); + if (ptr) { + ret = ptr(req, data); + } + ASSERT_EQ(ret, DM_OK); + ServiceRegInfo readRegInfo; + const ServiceRegInfo* infoPtr = reinterpret_cast( + data.ReadRawData(sizeof(ServiceRegInfo)) + ); + memcpy(&readRegInfo, infoPtr, sizeof(ServiceRegInfo)); + ASSERT_EQ(readRegInfo.customData, testRegInfo.customData); + ASSERT_EQ(readRegInfo.dataLen, testRegInfo.dataLen); + int32_t readRegServiceId = data.ReadInt32(); + ASSERT_EQ(readRegServiceId, testRegServiceId); +} + +HWTEST_F(IpcCmdParserServiceTest, ReadResponseFunc_036, testing::ext::TestSize.Level0) +{ + int32_t cmdCode = REGISTER_SERVICE_INFO; + + MessageParcel emptyReply; + std::shared_ptr nullRsp = nullptr; + ReadResponseFunc nullFunc = GetResponseFunc(cmdCode); + int retNull = ERR_DM_UNSUPPORTED_IPC_COMMAND; + if (nullFunc) { + retNull = nullFunc(emptyReply, nullRsp); + } + ASSERT_EQ(retNull, ERR_DM_FAILED); +} + +HWTEST_F(IpcCmdParserServiceTest, ReadResponseFunc_037, testing::ext::TestSize.Level0) +{ + int32_t cmdCode = REGISTER_SERVICE_INFO; + + MessageParcel validReply; + std::shared_ptr validRsp = std::make_shared(); + int32_t expectedErrCode = 0; + int32_t expectedRegServiceId = 3003; + validReply.WriteInt32(expectedErrCode); + validReply.WriteInt32(expectedRegServiceId); + + ReadResponseFunc validFunc = GetResponseFunc(cmdCode); + int retValid = ERR_DM_UNSUPPORTED_IPC_COMMAND; + if (validFunc) { + retValid = validFunc(validReply, validRsp); + } + ASSERT_EQ(retValid, DM_OK); + ASSERT_EQ(validRsp->GetErrCode(), expectedErrCode); + ASSERT_EQ(validRsp->GetRegServiceId(), expectedRegServiceId); +} + +HWTEST_F(IpcCmdParserServiceTest, SetIpcRequestFunc_031, testing::ext::TestSize.Level0) +{ + int32_t cmdCode = UNREGISTER_SERVICE_INFO; + MessageParcel data; + std::shared_ptr req = nullptr; + int ret = ERR_DM_UNSUPPORTED_IPC_COMMAND; + + SetIpcRequestFunc ptr = GetIpcRequestFunc(cmdCode); + if (ptr) { + ret = ptr(req, data); + } + ASSERT_EQ(ret, ERR_DM_FAILED); +} +HWTEST_F(IpcCmdParserServiceTest, SetIpcRequestFunc_032, testing::ext::TestSize.Level0) +{ + int32_t cmdCode = UNREGISTER_SERVICE_INFO; + MessageParcel data; + std::shared_ptr req = nullptr; + int ret = ERR_DM_UNSUPPORTED_IPC_COMMAND; + SetIpcRequestFunc ptr = GetIpcRequestFunc(cmdCode); + + req = std::make_shared(); + std::shared_ptr unregReq = + std::static_pointer_cast(req); + + int32_t testRegServiceId = 4004; + unregReq->SetRegServiceId(testRegServiceId); + if (ptr) { + ret = ptr(req, data); + } + ASSERT_EQ(ret, DM_OK); + int32_t readRegServiceId = data.ReadInt32(); + ASSERT_EQ(readRegServiceId, testRegServiceId); +} + +HWTEST_F(IpcCmdParserServiceTest, ReadResponseFunc_038, testing::ext::TestSize.Level0) +{ + int32_t cmdCode = UNREGISTER_SERVICE_INFO; + + + MessageParcel emptyReply; + std::shared_ptr nullRsp = nullptr; + ReadResponseFunc nullFunc = GetResponseFunc(cmdCode); + int retNull = ERR_DM_UNSUPPORTED_IPC_COMMAND; + if (nullFunc) { + retNull = nullFunc(emptyReply, nullRsp); + } + ASSERT_EQ(retNull, ERR_DM_FAILED); +} + +HWTEST_F(IpcCmdParserServiceTest, ReadResponseFunc_039, testing::ext::TestSize.Level0) +{ + int32_t cmdCode = UNREGISTER_SERVICE_INFO; + + MessageParcel validReply; + std::shared_ptr validRsp = std::make_shared(); + int32_t expectedErrCode = 0; + validReply.WriteInt32(expectedErrCode); + + ReadResponseFunc validFunc = GetResponseFunc(cmdCode); + int retValid = ERR_DM_UNSUPPORTED_IPC_COMMAND; + if (validFunc) { + retValid = validFunc(validReply, validRsp); + } + ASSERT_EQ(retValid, DM_OK); + ASSERT_EQ(validRsp->GetErrCode(), expectedErrCode); +} + +HWTEST_F(IpcCmdParserServiceTest, OnIpcCmdFunc_057, testing::ext::TestSize.Level1) +{ + int32_t cmdCode = REGISTER_SERVICE_INFO; + MessageParcel data; + MessageParcel reply; + + ServiceRegInfo regInfo; + regInfo.serviceInfo.serviceId = 123; + regInfo.serviceInfo.serviceType = 1; + regInfo.serviceInfo.serviceName = "TestService"; + regInfo.serviceInfo.serviceDisplayName = "TestDisplayName"; + int32_t regServiceId = 0; + + data.WriteRawData(®Info, sizeof(ServiceRegInfo)); + data.WriteInt32(regServiceId); + + OnIpcCmdFunc func = GetIpcCmdFunc(cmdCode); + ASSERT_TRUE(func != nullptr); + + int32_t ret = func(data, reply); + ASSERT_EQ(ret, DM_OK); + + ASSERT_GE(reply.GetDataSize(), sizeof(int32_t) * 2); + int32_t replyResult = reply.ReadInt32(); + int32_t replyRegServiceId = reply.ReadInt32(); + ASSERT_EQ(replyResult, DM_OK); + ASSERT_GE(replyRegServiceId, 0); +} + +HWTEST_F(IpcCmdParserServiceTest, OnIpcCmdFunc_058, testing::ext::TestSize.Level1) +{ + int32_t cmdCode = UNREGISTER_SERVICE_INFO; + MessageParcel data; + MessageParcel reply; + int32_t regServiceId = 123; + data.WriteInt32(regServiceId); + + OnIpcCmdFunc func = GetIpcCmdFunc(cmdCode); + ASSERT_TRUE(func != nullptr); + + int32_t ret = func(data, reply); + ASSERT_EQ(ret, DM_OK); + + ASSERT_GE(reply.GetDataSize(), sizeof(int32_t)); + int32_t replyResult = reply.ReadInt32(); + ASSERT_EQ(replyResult, DM_OK); +} + +HWTEST_F(IpcCmdParserServiceTest, OnIpcCmdFunc_059, testing::ext::TestSize.Level0) +{ + int32_t cmdCode = STOP_PUBLISH_SERVICE; + int32_t ret = ERR_DM_UNSUPPORTED_IPC_COMMAND; + MessageParcel data; + MessageParcel reply; + + int64_t serviceId = 3003; + data.WriteInt64(serviceId); + + OnIpcCmdFunc ptr = GetIpcCmdFunc(cmdCode); + if (ptr) { + ret = ptr(data, reply); + } + + ASSERT_EQ(ret, DM_OK); + + int32_t result = reply.ReadInt32(); +} + +HWTEST_F(IpcCmdParserServiceTest, SetIpcRequestFunc_033, testing::ext::TestSize.Level1) +{ + int32_t cmdCode = SERVICE_PUBLISH_RESULT; + MessageParcel data; + + auto pReq = std::make_shared(); + int32_t publishId = 123; + int32_t result = 0; + pReq->SetPublishId(publishId); + pReq->SetResult(result); + + SetIpcRequestFunc func = GetIpcRequestFunc(cmdCode); + ASSERT_TRUE(func != nullptr); + + int32_t ret = func(pReq, data); + ASSERT_EQ(ret, DM_OK); + + ASSERT_GE(data.GetDataSize(), sizeof(int32_t) * 2); + int32_t outPublishId = data.ReadInt32(); + int32_t outResult = data.ReadInt32(); + ASSERT_EQ(outPublishId, publishId); + ASSERT_EQ(outResult, result); +} + +HWTEST_F(IpcCmdParserServiceTest, ReadResponseFunc_040, testing::ext::TestSize.Level1) +{ + int32_t cmdCode = SERVICE_PUBLISH_RESULT; + MessageParcel reply; + int32_t expectedErrCode = 123; + reply.WriteInt32(expectedErrCode); + + auto pBaseRsp = std::make_shared(); + + ReadResponseFunc func = GetResponseFunc(cmdCode); + ASSERT_TRUE(func != nullptr); + + int32_t ret = func(reply, pBaseRsp); + + ASSERT_EQ(ret, DM_OK); + ASSERT_EQ(pBaseRsp->GetErrCode(), expectedErrCode); + + ASSERT_FALSE(reply.ReadInt32()); +} + } // namespace } // namespace DistributedHardware } // namespace OHOS \ No newline at end of file diff --git a/test/unittest/device_manager_impl_test.cpp b/test/unittest/device_manager_impl_test.cpp index 1070444fa..84674aa4b 100644 --- a/test/unittest/device_manager_impl_test.cpp +++ b/test/unittest/device_manager_impl_test.cpp @@ -28,6 +28,7 @@ void DeviceManagerImplTest::SetUp() void DeviceManagerImplTest::TearDown() { + DeviceManagerNotify::GetInstance().UnregisterServicePublishCallback(testParam.publishId); } void DeviceManagerImplTest::SetUpTestCase() @@ -186,6 +187,299 @@ HWTEST_F(DeviceManagerImplTest, PublishDeviceDiscovery3, testing::ext::TestSize. ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr; } + +HWTEST_F(DeviceManagerImplTest, StartPublishService_001, testing::ext::TestSize.Level0) +{ + + originalIpcProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_; + mockIpc = std::make_shared(1); + DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockIpc; + + PublishServiceParam param; + param.publishId = "test_publish_id_001"; + std::string mode = "test_mode"; + std::shared_ptr callback = nullptr; + int64_t serviceId = 1001; + int32_t ret = DeviceManagerImpl::GetInstance().StartPublishService(mode, param, callback, serviceId); + ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); + + DeviceManagerImpl::GetInstance().ipcClientProxy_ = originalIpcProxy; + mockIpc.reset(); +} + +HWTEST_F(DeviceManagerImplTest, StartPublishService_002, testing::ext::TestSize.Level0) +{ + originalIpcProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_; + mockIpc = std::make_shared(1); + DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockIpc; + + PublishServiceParam param; + param.publishId = "test_publish_id_002"; + std::string mode = "test_mode"; + auto callback = std::make_shared(); + int64_t serviceId = 1002; + mockIpc->sendRequestRet = ERR_DM_IPC_SEND_REQUEST_FAILED; + int32_t ret = DeviceManagerImpl::GetInstance().StartPublishService(mode, param, callback, serviceId); + ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); + + DeviceManagerImpl::GetInstance().ipcClientProxy_ = originalIpcProxy; + mockIpc.reset(); +} + +/** + * @tc.name: StartPublishService_003 + * @tc.desc: 测试StartPublishService IPC响应错误的情况 + * @tc.type: FUNC + */ +HWTEST_F(DeviceManagerImplTest, StartPublishService_003, testing::ext::TestSize.Level0) +{ + originalIpcProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_; + mockIpc = std::make_shared(1); + DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockIpc; + + PublishServiceParam param; + param.publishId = "test_publish_id_003"; + std::string mode = "test_mode"; + auto callback = std::make_shared(); + int64_t serviceId = 1003; + mockIpc->sendRequestRet = DM_OK; + mockIpc->rspErrCode = ERR_DM_INTERNAL_ERROR; + int32_t ret = DeviceManagerImpl::GetInstance().StartPublishService(mode, param, callback, serviceId); + ASSERT_EQ(ret, ERR_DM_INTERNAL_ERROR); + + DeviceManagerImpl::GetInstance().ipcClientProxy_ = originalIpcProxy; + mockIpc.reset(); +} + +/** + * @tc.name: StartPublishService_004 + * @tc.desc: 测试StartPublishService成功的情况 + * @tc.type: FUNC + */ +HWTEST_F(DeviceManagerImplTest, StartPublishService_004, testing::ext::TestSize.Level0) +{ + originalIpcProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_; + mockIpc = std::make_shared(1); + DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockIpc; + + PublishServiceParam param; + param.publishId = "test_publish_id_004"; + std::string mode = "test_mode"; + auto callback = std::make_shared(); + int64_t serviceId = 1004; + mockIpc->sendRequestRet = DM_OK; + mockIpc->rspErrCode = DM_OK; + int32_t ret = DeviceManagerImpl::GetInstance().StartPublishService(mode, param, callback, serviceId); + ASSERT_EQ(ret, DM_OK); + + DeviceManagerImpl::GetInstance().ipcClientProxy_ = originalIpcProxy; + mockIpc.reset(); +} + +/** + * @tc.name: StopPublishService_001 + * @tc.desc: 测试StopPublishService发送IPC请求失败的情况 + * @tc.type: FUNC + */ +HWTEST_F(DeviceManagerImplTest, StopPublishService_001, testing::ext::TestSize.Level0) +{ + originalIpcProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_; + mockIpc = std::make_shared(1); + DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockIpc; + + int64_t serviceId = 2001; + mockIpc->sendRequestRet = ERR_DM_IPC_SEND_REQUEST_FAILED; + int32_t ret = DeviceManagerImpl::GetInstance().StopPublishService(serviceId); + ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); + + DeviceManagerImpl::GetInstance().ipcClientProxy_ = originalIpcProxy; + mockIpc.reset(); +} + +/** + * @tc.name: StopPublishService_002 + * @tc.desc: 测试StopPublishService IPC响应错误的情况 + * @tc.type: FUNC + */ +HWTEST_F(DeviceManagerImplTest, StopPublishService_002, testing::ext::TestSize.Level0) +{ + originalIpcProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_; + mockIpc = std::make_shared(1); + DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockIpc; + + int64_t serviceId = 2002; + mockIpc->sendRequestRet = DM_OK; + mockIpc->rspErrCode = ERR_DM_SERVICE_NOT_FOUND; + int32_t ret = DeviceManagerImpl::GetInstance().StopPublishService(serviceId); + ASSERT_EQ(ret, ERR_DM_SERVICE_NOT_FOUND); + + DeviceManagerImpl::GetInstance().ipcClientProxy_ = originalIpcProxy; + mockIpc.reset(); +} + +/** + * @tc.name: StopPublishService_003 + * @tc.desc: 测试StopPublishService成功的情况 + * @tc.type: FUNC + */ +HWTEST_F(DeviceManagerImplTest, StopPublishService_003, testing::ext::TestSize.Level0) +{ + originalIpcProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_; + mockIpc = std::make_shared(1); + DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockIpc; + + int64_t serviceId = 2003; + mockIpc->sendRequestRet = DM_OK; + mockIpc->rspErrCode = DM_OK; + int32_t ret = DeviceManagerImpl::GetInstance().StopPublishService(serviceId); + ASSERT_EQ(ret, DM_OK); + + DeviceManagerImpl::GetInstance().ipcClientProxy_ = originalIpcProxy; + mockIpc.reset(); +} + +/** + * @tc.name: RegisterServiceInfo_001 + * @tc.desc: 测试RegisterServiceInfo发送IPC请求失败的情况 + * @tc.type: FUNC + */ +HWTEST_F(DeviceManagerImplTest, RegisterServiceInfo_001, testing::ext::TestSize.Level0) +{ + originalIpcProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_; + mockIpc = std::make_shared(1); + DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockIpc; + + ServiceRegInfo serviceInfo; + serviceInfo.serviceId = "service_3001"; + int32_t regServiceId = 3001; + mockIpc->sendRequestRet = ERR_DM_IPC_SEND_REQUEST_FAILED; + int32_t ret = DeviceManagerImpl::GetInstance().RegisterServiceInfo(serviceInfo, regServiceId); + ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); + + DeviceManagerImpl::GetInstance().ipcClientProxy_ = originalIpcProxy; + mockIpc.reset(); +} + +/** + * @tc.name: RegisterServiceInfo_002 + * @tc.desc: 测试RegisterServiceInfo IPC响应错误的情况 + * @tc.type: FUNC + */ +HWTEST_F(DeviceManagerImplTest, RegisterServiceInfo_002, testing::ext::TestSize.Level0) +{ + originalIpcProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_; + mockIpc = std::make_shared(1); + DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockIpc; + + ServiceRegInfo serviceInfo; + serviceInfo.serviceId = "service_3002"; + int32_t regServiceId = 3002; + mockIpc->sendRequestRet = DM_OK; + mockIpc->rspErrCode = ERR_DM_REGISTER_FAILED; + int32_t ret = DeviceManagerImpl::GetInstance().RegisterServiceInfo(serviceInfo, regServiceId); + ASSERT_EQ(ret, ERR_DM_REGISTER_FAILED); + + DeviceManagerImpl::GetInstance().ipcClientProxy_ = originalIpcProxy; + mockIpc.reset(); +} + +/** + * @tc.name: RegisterServiceInfo_003 + * @tc.desc: 测试RegisterServiceInfo成功的情况 + * @tc.type: FUNC + */ +HWTEST_F(DeviceManagerImplTest, RegisterServiceInfo_003, testing::ext::TestSize.Level0) +{ + originalIpcProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_; + mockIpc = std::make_shared(1); + DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockIpc; + + ServiceRegInfo serviceInfo; + serviceInfo.serviceId = "service_3003"; + int32_t regServiceId = 3003; + mockIpc->sendRequestRet = DM_OK; + mockIpc->rspErrCode = DM_OK; + int32_t ret = DeviceManagerImpl::GetInstance().RegisterServiceInfo(serviceInfo, regServiceId); + ASSERT_EQ(ret, DM_OK); + + DeviceManagerImpl::GetInstance().ipcClientProxy_ = originalIpcProxy; + mockIpc.reset(); +} + +/** + * @tc.name: UnRegisterServiceInfo_001 + * @tc.desc: 测试UnRegisterServiceInfo发送IPC请求失败的情况 + * @tc.type: FUNC + */ +HWTEST_F(DeviceManagerImplTest, UnRegisterServiceInfo_001, testing::ext::TestSize.Level0) +{ + originalIpcProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_; + mockIpc = std::make_shared(1); + DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockIpc; + + int32_t regServiceId = 4001; + mockIpc->sendRequestRet = ERR_DM_IPC_SEND_REQUEST_FAILED; + int32_t ret = DeviceManagerImpl::GetInstance().UnRegisterServiceInfo(regServiceId); + ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); + + DeviceManagerImpl::GetInstance().ipcClientProxy_ = originalIpcProxy; + mockIpc.reset(); +} + +/** + * @tc.name: UnRegisterServiceInfo_002 + * @tc.desc: 测试UnRegisterServiceInfo IPC响应错误的情况 + * @tc.type: FUNC + */ +HWTEST_F(DeviceManagerImplTest, UnRegisterServiceInfo_002, testing::ext::TestSize.Level0) +{ + originalIpcProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_; + mockIpc = std::make_shared(1); + DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockIpc; + + int32_t regServiceId = 4002; + mockIpc->sendRequestRet = DM_OK; + mockIpc->rspErrCode = ERR_DM_UNREGISTER_FAILED; + int32_t ret = DeviceManagerImpl::GetInstance().UnRegisterServiceInfo(regServiceId); + ASSERT_EQ(ret, ERR_DM_UNREGISTER_FAILED); + + DeviceManagerImpl::GetInstance().ipcClientProxy_ = originalIpcProxy; + mockIpc.reset(); +} + +/** + * @tc.name: UnRegisterServiceInfo_003 + * @tc.desc: 测试UnRegisterServiceInfo成功的情况 + * @tc.type: FUNC + */ +HWTEST_F(DeviceManagerImplTest, UnRegisterServiceInfo_003, testing::ext::TestSize.Level0) +{ + originalIpcProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_; + mockIpc = std::make_shared(1); + DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockIpc; + + int32_t regServiceId = 4003; + mockIpc->sendRequestRet = DM_OK; + mockIpc->rspErrCode = DM_OK; + int32_t ret = DeviceManagerImpl::GetInstance().UnRegisterServiceInfo(regServiceId); + ASSERT_EQ(ret, DM_OK); + + DeviceManagerImpl::GetInstance().ipcClientProxy_ = originalIpcProxy; + mockIpc.reset(); +} + +/** + * @tc.name: RegisterPublishCallback_001 + * @tc.desc: + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DeviceManagerImplTest, RegisterPublishCallback_001, testing::ext::TestSize.Level0) +{ + int32_t ret = DeviceManagerImpl::RegisterPublishCallback(); + EXPECT_EQ(ret, ERR_OK); +} + } // namespace void DeviceDiscoveryCallback::OnDiscoverySuccess(uint16_t subscribeId) diff --git a/test/unittest/device_manager_impl_test.h b/test/unittest/device_manager_impl_test.h index 78f8079c3..c62b1dbaa 100644 --- a/test/unittest/device_manager_impl_test.h +++ b/test/unittest/device_manager_impl_test.h @@ -23,6 +23,10 @@ #include "device_manager_callback.h" #include "device_manager_impl.h" #include "mock/mock_ipc_client_proxy.h" +#include "dm_device_info.h" +#include "dm_subscribe_info.h" +#include "device_manager_notify.h" +#include "dm_publish_info.h" namespace OHOS { namespace DistributedHardware { @@ -33,9 +37,14 @@ public: void SetUp(); void TearDown(); + std::unique_ptr deviceManager; + PublishServiceParam testParam; + DmDiscoverMode testMode; + std::shared_ptr mockCallback; + int64_t testServiceId; + std::shared_ptr mockIpc; + std::shared_ptr originalIpcProxy; private: - std::shared_ptr test_callback_ = nullptr; - std::shared_ptr testPublishCallback_ = nullptr; }; class DeviceDiscoveryCallback : public DiscoveryCallback { @@ -61,6 +70,41 @@ public: } void OnPublishResult(int32_t publishId, int32_t failedReason) override; }; + +class MockServicePublishCallback : public ServicePublishCallback { +public: + void OnPublishResult(int32_t result, const std::string &publishId) + { + } +}; + +class MockIpcClientProxy : public IpcClientProxy { +public: + explicit MockIpcClientProxy(int dummy) : dummy_(dummy) {} + int32_t SendRequest(uint32_t cmd, std::shared_ptr req, std::shared_ptr rsp) { + if (sendRequestRet != DM_OK) { + return sendRequestRet; + } + rsp->SetErrCode(rspErrCode); + return DM_OK; + } + int32_t sendRequestRet = DM_OK; + int32_t rspErrCode = DM_OK; + int dummy_; +}; + +class MockIpcRsp : public IpcRsp { +private: + int32_t errCode; +public: + MockIpcRsp(int32_t code) : errCode(code) + { + } + int32_t GetErrCode() const + { + return errCode; + } +}; } // namespace DistributedHardware } // namespace OHOS diff --git a/test/unittest/mock/device_manager_service_impl_mock.h b/test/unittest/mock/device_manager_service_impl_mock.h index 2886de7e3..92921e063 100644 --- a/test/unittest/mock/device_manager_service_impl_mock.h +++ b/test/unittest/mock/device_manager_service_impl_mock.h @@ -19,6 +19,7 @@ #include #include "device_manager_service_impl.h" +#include "ipc_start_publish_service_req.h" namespace OHOS { namespace DistributedHardware { @@ -52,11 +53,20 @@ public: const DmAccessCallee &callee, const std::string &sinkUdid) = 0; public: static inline std::shared_ptr dmDeviceManagerServiceImpl = nullptr; + MOCK_METHOD(int32_t, HandleStopPublishService, (const std::string &pkgName, const std::string &serviceId)); }; class DeviceManagerServiceImplMock : public DmDeviceManagerServiceImpl { public: + MOCK_METHOD(int32_t, HandleStopPublishService, (int64_t serviceId)); MOCK_METHOD(int32_t, StopAuthenticateDevice, (const std::string &)); + MOCK_METHOD(int32_t, GenerateServiceId, (int32_t &serviceId)); + MOCK_METHOD(int32_t, GetServiceBindLocalInfo, (ServiceBindLocalInfo &localInfo)); + MOCK_METHOD(int32_t, ValidateForegroundUser, (int32_t userId)); + MOCK_METHOD(ServiceInfoProfile, CreateServiceInfoProfile, (const ServiceInfo ¶m, const DmDeviceInfo &deviceInfo, int32_t userId)); + MOCK_METHOD(int32_t, ConvertServiceInfoProfileByRegInfo, (const ServiceInfo ®Info, ServiceInfoProfile &profile)); + MOCK_METHOD(int32_t, GenerateRegServiceId, (int32_t ®ServiceId)); + MOCK_METHOD(int32_t, PutServiceInfoProfile, (const ServiceInfoProfile &profile)); MOCK_METHOD(int32_t, GetBindLevel, (const std::string &, const std::string &, const std::string &, uint64_t &)); MOCK_METHOD(int32_t, UnBindDevice, (const std::string &, const std::string &, int32_t)); MOCK_METHOD((std::multimap), GetDeviceIdAndUserId, (int32_t, const std::string &)); @@ -77,6 +87,10 @@ public: const DmAccessCallee &callee, const std::string &sinkUdid)); MOCK_METHOD(bool, CheckIsSameAccount, (const DmAccessCaller &caller, const std::string &srcUdid, const DmAccessCallee &callee, const std::string &sinkUdid)); + MOCK_METHOD(bool, IsDMServiceAdapterResidentLoad, ()); + MOCK_METHOD(int32_t, HandleStopPublishService, (const std::string &pkgName, const std::string &serviceId)); + MOCK_METHOD(int32_t, StartPublishService, (const std::string &pkgName, + PublishServiceParam &publishServiceParam, int64_t &serviceId)); }; } } diff --git a/test/unittest/mock/deviceprofile_connector_mock.h b/test/unittest/mock/deviceprofile_connector_mock.h index 17d9b9333..5850c8726 100644 --- a/test/unittest/mock/deviceprofile_connector_mock.h +++ b/test/unittest/mock/deviceprofile_connector_mock.h @@ -124,6 +124,11 @@ public: MOCK_METHOD(void, CacheAcerAclId, (const DistributedDeviceProfile::AccessControlProfile &profile, std::vector &aclInfos)); MOCK_METHOD(bool, IsLnnAcl, (const DistributedDeviceProfile::AccessControlProfile &profile)); + MOCK_METHOD(int32_t, PutServiceInfoProfile, (const ServiceInfoProfile &profile)); + MOCK_METHOD(int32_t, DeleteServiceInfoProfile, (int32_t serviceId)); + MOCK_METHOD(int32_t, UpdateAccessControlProfile, (const DistributedDeviceProfile::AccessControlProfile &profile)); + MOCK_METHOD(int32_t, DeleteServiceInfoProfile, (int32_t serviceId, bool isResident, int32_t userId)); + MOCK_METHOD(int32_t, GetServiceInfoProfileByServiceId, (int32_t serviceId, ServiceInfoProfile &profile)); }; } } diff --git a/test/unittest/mock/dm_crypto_mock.h b/test/unittest/mock/dm_crypto_mock.h index 0bc47fe35..c807872d2 100644 --- a/test/unittest/mock/dm_crypto_mock.h +++ b/test/unittest/mock/dm_crypto_mock.h @@ -44,6 +44,7 @@ public: MOCK_METHOD(int32_t, GetUdidHash, (const std::string &, unsigned char *)); MOCK_METHOD(std::string, GetGroupIdHash, (const std::string &)); MOCK_METHOD(int32_t, ConvertUdidHashToAnoyDeviceId, (const std::string &, const std::string &, DmKVValue &)); + MOCK_METHOD(int32_t, RAND_bytes, (unsigned char *, int32_t)); }; } } diff --git a/test/unittest/mock/ipc_cmd_register_mock.h b/test/unittest/mock/ipc_cmd_register_mock.h index 499b0b62b..7a7e007be 100644 --- a/test/unittest/mock/ipc_cmd_register_mock.h +++ b/test/unittest/mock/ipc_cmd_register_mock.h @@ -36,6 +36,7 @@ class IpcCmdRegisterMock : public DmIpcCmdRegister { public: MOCK_METHOD(int32_t, SetRequest, (int32_t, std::shared_ptr, MessageParcel &)); MOCK_METHOD(int32_t, OnIpcCmd, (int32_t, MessageParcel &, MessageParcel &)); + MOCK_METHOD(int32_t, SendRequest, (int32_t, std::shared_ptr, std::shared_ptr)); }; } } diff --git a/test/unittest/mock/ipc_server_listener_mock.cpp b/test/unittest/mock/ipc_server_listener_mock.cpp index b46d8e232..0b11fd59d 100644 --- a/test/unittest/mock/ipc_server_listener_mock.cpp +++ b/test/unittest/mock/ipc_server_listener_mock.cpp @@ -17,6 +17,8 @@ #include "gtest/gtest.h" + + namespace OHOS { namespace DistributedHardware { std::vector IpcServerListener::GetAllProcessInfo() @@ -28,5 +30,6 @@ std::set IpcServerListener::GetSystemSA() { return DmIpcServerListener::dmIpcServerListener->GetSystemSA(); } + } // namespace DistributedHardware } // namespace OHOS \ No newline at end of file diff --git a/test/unittest/mock/ipc_server_listener_mock.h b/test/unittest/mock/ipc_server_listener_mock.h index 951be74c4..c212faee2 100644 --- a/test/unittest/mock/ipc_server_listener_mock.h +++ b/test/unittest/mock/ipc_server_listener_mock.h @@ -28,6 +28,7 @@ public: public: virtual std::vector GetAllProcessInfo() = 0; virtual std::set GetSystemSA() = 0; + virtual int32_t SendRequest(int32_t code, std::shared_ptr req, std::shared_ptr rsp) = 0; public: static inline std::shared_ptr dmIpcServerListener = nullptr; }; @@ -36,6 +37,7 @@ class IpcServerListenerMock : public DmIpcServerListener { public: MOCK_METHOD((std::vector), GetAllProcessInfo, ()); MOCK_METHOD((std::set), GetSystemSA, ()); + MOCK_METHOD(int32_t, SendRequest, (int32_t, std::shared_ptr, std::shared_ptr)); }; } } -- Gitee From fb79f58be29a9107b1f781da6058938a30a7b98f Mon Sep 17 00:00:00 2001 From: wym <14509651+i-know-what-to-do@user.noreply.gitee.com> Date: Wed, 27 Aug 2025 10:28:08 +0800 Subject: [PATCH 07/12] DM_TDD --- .../device_manager_notify_fuzzer.cpp | 31 ++++++-------- .../devicemanagerservice_fuzzer/BUILD.gn | 2 +- .../device_manager_service_fuzzer.cpp | 14 ++++++- .../devicemanagerserviceimpl_fuzzer/BUILD.gn | 2 +- .../corpus/init | 2 +- .../device_manager_service_impl_fuzzer.cpp | 5 +-- .../device_manager_service_impl_fuzzer.h | 7 ++-- .../BUILD.gn | 2 +- .../corpus/init | 2 +- ...device_manager_service_listener_fuzzer.cpp | 11 +++-- .../device_manager_service_listener_fuzzer.h | 2 +- .../project.xml | 2 +- .../device_profile_connector_fuzzer.cpp | 14 ++++--- .../ipc_model_codec_fuzzer.cpp | 3 +- test/unittest/BUILD.gn | 2 +- .../UTTest_device_manager_notify_four.cpp | 11 ++--- .../UTTest_device_manager_service_impl.cpp | 40 +------------------ ...UTTest_device_manager_service_listener.cpp | 9 ++--- test/unittest/UTTest_device_manager_utils.cpp | 3 +- test/unittest/UTTest_device_manager_utils.h | 13 +++--- test/unittest/device_manager_impl_test.cpp | 2 +- test/unittest/device_manager_impl_test.h | 6 +-- .../mock/device_manager_service_impl_mock.h | 2 +- 23 files changed, 75 insertions(+), 112 deletions(-) diff --git a/test/servicesfuzztest/devicemanagernotify_fuzzer/device_manager_notify_fuzzer.cpp b/test/servicesfuzztest/devicemanagernotify_fuzzer/device_manager_notify_fuzzer.cpp index 6c44d65ce..abbfb3678 100644 --- a/test/servicesfuzztest/devicemanagernotify_fuzzer/device_manager_notify_fuzzer.cpp +++ b/test/servicesfuzztest/devicemanagernotify_fuzzer/device_manager_notify_fuzzer.cpp @@ -1,5 +1,5 @@ /* - * 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 @@ -16,44 +16,38 @@ #include #include #include - #include #include #include #include +#include #include +#include "device_manager_notify.h" +#include "device_manager_notify_fuzzer.h" +#include "dm_device_info.h" +#include "dm_constants.h" #include "ipc_client_manager.h" #include "ipc_set_useroperation_req.h" #include "ipc_rsp.h" #include "ipc_def.h" -#include "device_manager_notify.h" -#include "dm_device_info.h" #include "ipc_client_stub.h" #include "ipc_register_listener_req.h" #include "ipc_remote_broker.h" #include "iremote_object.h" #include "iservice_registry.h" -#include "dm_constants.h" #include "system_ability_definition.h" -#include "device_manager_notify_fuzzer.h" -#include namespace OHOS { namespace DistributedHardware { class MockServicePublishCallback : public ServicePublishCallback { public: - void OnServicePublishResult(int64_t serviceId, int32_t reason) override - { - lastServiceId_ = serviceId; - lastReason_ = reason; + void OnServicePublishResult(int64_t serviceId, int32_t reason) override { } - int64_t lastServiceId_ = 0; - int32_t lastReason_ = 0; }; void DeviceManagerNotifyUnRegisterFuzzTest(const uint8_t* data, size_t size) { - if ((data == nullptr) || (size == 0)) { + if ((data == nullptr) || (size < sizeof(int64_t))) { return; } @@ -74,7 +68,7 @@ void DeviceManagerNotifyUnRegisterFuzzTest(const uint8_t* data, size_t size) void DeviceManagerNotifyDeviceStatusFuzzTest(const uint8_t* data, size_t size) { - if ((data == nullptr) || (size == 0)) { + if ((data == nullptr) || (size < sizeof(int64_t))) { return; } @@ -117,7 +111,7 @@ void DeviceManagerNotifyOnPublishResultFuzzTest(const uint8_t* data, size_t size void RegisterServicePublishCallbackFuzzTest(const uint8_t* data, size_t size) { - if ((data == nullptr) || (size == 0)) { + if ((data == nullptr) || (size < sizeof(int64_t))) { return; } @@ -129,7 +123,7 @@ void RegisterServicePublishCallbackFuzzTest(const uint8_t* data, size_t size) void UnRegisterServicePublishCallbackFuzzTest(const uint8_t* data, size_t size) { - if ((data == nullptr) || (size == 0)) { + if ((data == nullptr) || (size < sizeof(int64_t))) { return; } @@ -140,7 +134,8 @@ void UnRegisterServicePublishCallbackFuzzTest(const uint8_t* data, size_t size) void OnServicePublishResultFuzzTest(const uint8_t* data, size_t size) { - if ((data == nullptr) || (size == 0)) { + const size_t minSize = sizeof(int64_t) + sizeof(int32_t); + if ((data == nullptr) || (size < minSize)) { return; } diff --git a/test/servicesfuzztest/devicemanagerservice_fuzzer/BUILD.gn b/test/servicesfuzztest/devicemanagerservice_fuzzer/BUILD.gn index 32a91f35e..cb2bc8283 100644 --- a/test/servicesfuzztest/devicemanagerservice_fuzzer/BUILD.gn +++ b/test/servicesfuzztest/devicemanagerservice_fuzzer/BUILD.gn @@ -1,4 +1,4 @@ -# 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 diff --git a/test/servicesfuzztest/devicemanagerservice_fuzzer/device_manager_service_fuzzer.cpp b/test/servicesfuzztest/devicemanagerservice_fuzzer/device_manager_service_fuzzer.cpp index 7291f39b7..fdb81b294 100644 --- a/test/servicesfuzztest/devicemanagerservice_fuzzer/device_manager_service_fuzzer.cpp +++ b/test/servicesfuzztest/devicemanagerservice_fuzzer/device_manager_service_fuzzer.cpp @@ -15,15 +15,25 @@ #include #include +#include #include "device_manager_service.h" #include "device_manager_service_fuzzer.h" -#include namespace OHOS { namespace DistributedHardware { void DeviceManagerServiceFuzzTest(const uint8_t* data, size_t size) { - if ((data == nullptr) || (size < sizeof(int32_t))) { + const int INT_COUNT = 8; + const int INT32_COUNT = 8; + const int INT64_COUNT = 6; + const int UINT16_COUNT = 1; + const int UINT32_COUNT = 1; + const size_t minSize = sizeof(int) * INT_COUNT + + sizeof(int32_t) * INT32_COUNT + + sizeof(int64_t) * INT64_COUNT + + sizeof(uint16_t) * UINT16_COUNT + + sizeof(uint32_t) * UINT32_COUNT; + if ((data == nullptr) || (size < minSize)) { return; } FuzzedDataProvider fdp(data, size); diff --git a/test/servicesfuzztest/devicemanagerserviceimpl_fuzzer/BUILD.gn b/test/servicesfuzztest/devicemanagerserviceimpl_fuzzer/BUILD.gn index 81c702bfa..da68cb1ba 100644 --- a/test/servicesfuzztest/devicemanagerserviceimpl_fuzzer/BUILD.gn +++ b/test/servicesfuzztest/devicemanagerserviceimpl_fuzzer/BUILD.gn @@ -1,4 +1,4 @@ -# 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 diff --git a/test/servicesfuzztest/devicemanagerserviceimpl_fuzzer/corpus/init b/test/servicesfuzztest/devicemanagerserviceimpl_fuzzer/corpus/init index 59aefb51c..a59f9d307 100644 --- a/test/servicesfuzztest/devicemanagerserviceimpl_fuzzer/corpus/init +++ b/test/servicesfuzztest/devicemanagerserviceimpl_fuzzer/corpus/init @@ -1,4 +1,4 @@ -# Copyright (c) 2020-2021 Huawei Device Co., Ltd. +# Copyright (c) 2020-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 diff --git a/test/servicesfuzztest/devicemanagerserviceimpl_fuzzer/device_manager_service_impl_fuzzer.cpp b/test/servicesfuzztest/devicemanagerserviceimpl_fuzzer/device_manager_service_impl_fuzzer.cpp index 41f49a193..158f37190 100644 --- a/test/servicesfuzztest/devicemanagerserviceimpl_fuzzer/device_manager_service_impl_fuzzer.cpp +++ b/test/servicesfuzztest/devicemanagerserviceimpl_fuzzer/device_manager_service_impl_fuzzer.cpp @@ -15,8 +15,8 @@ #include #include -#include "device_manager_service_impl_fuzzer.h" #include +#include "device_manager_service_impl_fuzzer.h" namespace OHOS { @@ -28,17 +28,14 @@ void DeviceManagerServiceImplFuzzTest(const uint8_t* data, size_t size) } FuzzedDataProvider fdp(data, size); - // Test HandleStopPublishService int64_t serviceId = fdp.ConsumeIntegral(); DeviceManagerServiceImpl::GetInstance().HandleStopPublishService(serviceId); } } } -/* Fuzzer entry point */ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { - /* Run your code on data */ OHOS::DistributedHardware::DeviceManagerServiceImplFuzzTest(data, size); return 0; diff --git a/test/servicesfuzztest/devicemanagerserviceimpl_fuzzer/device_manager_service_impl_fuzzer.h b/test/servicesfuzztest/devicemanagerserviceimpl_fuzzer/device_manager_service_impl_fuzzer.h index f4ff8b7df..b860f13ef 100644 --- a/test/servicesfuzztest/devicemanagerserviceimpl_fuzzer/device_manager_service_impl_fuzzer.h +++ b/test/servicesfuzztest/devicemanagerserviceimpl_fuzzer/device_manager_service_impl_fuzzer.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022 Huawei Device Co., Ltd. + * 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 @@ -20,12 +20,11 @@ #include #include +#include "access_control_profile.h" #include "device_manager_service_impl.h" #include "deviceprofile_connector.h" -#include "access_control_profile.h" -#include "json_object.h" #include "dm_log.h" - +#include "json_object.h" #define FUZZ_PROJECT_NAME "devicemanagerserviceimpl_fuzzer" #endif // DEVICE_MANAGER_SERVICE_IMPL_FUZZER_H \ No newline at end of file diff --git a/test/servicesfuzztest/devicemanagerservicelistener_fuzzer/BUILD.gn b/test/servicesfuzztest/devicemanagerservicelistener_fuzzer/BUILD.gn index 365646892..6280e6938 100644 --- a/test/servicesfuzztest/devicemanagerservicelistener_fuzzer/BUILD.gn +++ b/test/servicesfuzztest/devicemanagerservicelistener_fuzzer/BUILD.gn @@ -1,4 +1,4 @@ -# 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 diff --git a/test/servicesfuzztest/devicemanagerservicelistener_fuzzer/corpus/init b/test/servicesfuzztest/devicemanagerservicelistener_fuzzer/corpus/init index 59aefb51c..a59f9d307 100644 --- a/test/servicesfuzztest/devicemanagerservicelistener_fuzzer/corpus/init +++ b/test/servicesfuzztest/devicemanagerservicelistener_fuzzer/corpus/init @@ -1,4 +1,4 @@ -# Copyright (c) 2020-2021 Huawei Device Co., Ltd. +# Copyright (c) 2020-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 diff --git a/test/servicesfuzztest/devicemanagerservicelistener_fuzzer/device_manager_service_listener_fuzzer.cpp b/test/servicesfuzztest/devicemanagerservicelistener_fuzzer/device_manager_service_listener_fuzzer.cpp index 64344f1a5..fa300a275 100644 --- a/test/servicesfuzztest/devicemanagerservicelistener_fuzzer/device_manager_service_listener_fuzzer.cpp +++ b/test/servicesfuzztest/devicemanagerservicelistener_fuzzer/device_manager_service_listener_fuzzer.cpp @@ -16,14 +16,19 @@ #include #include #include +#include #include "device_manager_service_listener_fuzzer.h" #include "device_manager_service_listener.h" -#include + namespace OHOS { namespace DistributedHardware { void DeviceManagerServiceListenerFuzzTest(const uint8_t* data, size_t size) { + const size_t minSize = sizeof(int64_t) + sizeof(int32_t) + sizeof(int32_t); + if ((data == nullptr) || (size < minSize)) { + return; + } FuzzedDataProvider fdp(data, size); int64_t serviceId = fdp.ConsumeIntegral(); @@ -37,8 +42,8 @@ void DeviceManagerServiceListenerFuzzTest(const uint8_t* data, size_t size) DeviceManagerServiceListener listener; listener.OnServicePublishResult(processInfo, serviceId, publishResult); } -} -} +} // namespace DistributedHardware +} // namespace OHOS extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { diff --git a/test/servicesfuzztest/devicemanagerservicelistener_fuzzer/device_manager_service_listener_fuzzer.h b/test/servicesfuzztest/devicemanagerservicelistener_fuzzer/device_manager_service_listener_fuzzer.h index ed67939cc..921c3e52e 100644 --- a/test/servicesfuzztest/devicemanagerservicelistener_fuzzer/device_manager_service_listener_fuzzer.h +++ b/test/servicesfuzztest/devicemanagerservicelistener_fuzzer/device_manager_service_listener_fuzzer.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022 Huawei Device Co., Ltd. + * 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 diff --git a/test/servicesfuzztest/devicemanagerservicelistener_fuzzer/project.xml b/test/servicesfuzztest/devicemanagerservicelistener_fuzzer/project.xml index 0fea5df81..27c26d11b 100644 --- a/test/servicesfuzztest/devicemanagerservicelistener_fuzzer/project.xml +++ b/test/servicesfuzztest/devicemanagerservicelistener_fuzzer/project.xml @@ -18,7 +18,7 @@ 1000 - 10 + 300 4096 diff --git a/test/servicesfuzztest/deviceprofileconnector_fuzzer/device_profile_connector_fuzzer.cpp b/test/servicesfuzztest/deviceprofileconnector_fuzzer/device_profile_connector_fuzzer.cpp index d8e061ee5..b5e04e6bd 100644 --- a/test/servicesfuzztest/deviceprofileconnector_fuzzer/device_profile_connector_fuzzer.cpp +++ b/test/servicesfuzztest/deviceprofileconnector_fuzzer/device_profile_connector_fuzzer.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2024 Huawei Device Co., Ltd. + * 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 @@ -16,10 +16,9 @@ #include #include #include - +#include #include "deviceprofile_connector.h" #include "device_profile_connector_fuzzer.h" -#include #include "dm_device_info.h" namespace OHOS { @@ -70,7 +69,8 @@ void DeviceProfileConnectorFuzzTest(const uint8_t* data, size_t size) void GetServiceInfoProfileByServiceIdFuzzTest(const uint8_t* data, size_t size) { - if ((data == nullptr) || (size < sizeof(uint32_t))) { + const size_t minSize = sizeof(int64_t) + sizeof(int32_t) + sizeof(int32_t) + sizeof(int8_t) + sizeof(int64_t); + if ((data == nullptr) || (size < minSize)) { return; } @@ -92,7 +92,8 @@ void GetServiceInfoProfileByServiceIdFuzzTest(const uint8_t* data, size_t size) void PutServiceInfoProfileFuzzTest(const uint8_t* data, size_t size) { - if ((data == nullptr) || (size < sizeof(uint32_t))) { + const size_t minSize = sizeof(int32_t) + sizeof(int32_t) + sizeof(int64_t) + sizeof(int8_t) + sizeof(int64_t); + if ((data == nullptr) || (size < minSize)) { return; } @@ -113,7 +114,8 @@ void PutServiceInfoProfileFuzzTest(const uint8_t* data, size_t size) void DeleteServiceInfoProfileFuzzTest(const uint8_t* data, size_t size) { - if ((data == nullptr) || (size < sizeof(uint32_t))) { + const size_t minSize = sizeof(int32_t) + sizeof(int32_t) + sizeof(bool); + if ((data == nullptr) || (size < minSize)) { return; } diff --git a/test/servicesfuzztest/ipcmodelcodec_fuzzer/ipc_model_codec_fuzzer.cpp b/test/servicesfuzztest/ipcmodelcodec_fuzzer/ipc_model_codec_fuzzer.cpp index fd92708d6..1c3aaef24 100644 --- a/test/servicesfuzztest/ipcmodelcodec_fuzzer/ipc_model_codec_fuzzer.cpp +++ b/test/servicesfuzztest/ipcmodelcodec_fuzzer/ipc_model_codec_fuzzer.cpp @@ -16,9 +16,8 @@ #include -#include "ipc_model_codec.h" #include "dm_device_info.h" - +#include "ipc_model_codec.h" namespace OHOS { namespace DistributedHardware { diff --git a/test/unittest/BUILD.gn b/test/unittest/BUILD.gn index f66b159a3..d061b1c50 100644 --- a/test/unittest/BUILD.gn +++ b/test/unittest/BUILD.gn @@ -1,4 +1,4 @@ -# 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 diff --git a/test/unittest/UTTest_device_manager_notify_four.cpp b/test/unittest/UTTest_device_manager_notify_four.cpp index 6a0470e5c..a24938098 100644 --- a/test/unittest/UTTest_device_manager_notify_four.cpp +++ b/test/unittest/UTTest_device_manager_notify_four.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022-2023 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 @@ -14,17 +14,18 @@ */ #include "UTTest_device_manager_notify.h" + #include "device_manager_notify.h" +#include "device_manager_callback.h" #include "dm_device_info.h" #include "ipc_remote_broker.h" -#include "iremote_object.h" -#include "iservice_registry.h" -#include "system_ability_definition.h" #include "ipc_client_manager.h" #include "ipc_set_useroperation_req.h" #include "ipc_rsp.h" #include "ipc_def.h" -#include "device_manager_callback.h" +#include "iremote_object.h" +#include "iservice_registry.h" +#include "system_ability_definition.h" #include diff --git a/test/unittest/UTTest_device_manager_service_impl.cpp b/test/unittest/UTTest_device_manager_service_impl.cpp index f4497196e..449163319 100644 --- a/test/unittest/UTTest_device_manager_service_impl.cpp +++ b/test/unittest/UTTest_device_manager_service_impl.cpp @@ -13,11 +13,11 @@ * limitations under the License. */ -#include "UTTest_device_manager_service_impl.h" -#include "softbus_error_code.h" #include "common_event_support.h" #include "deviceprofile_connector.h" #include "distributed_device_profile_client.h" +#include "softbus_error_code.h" +#include "UTTest_device_manager_service_impl.h" using namespace testing; using namespace testing::ext; @@ -2126,42 +2126,6 @@ HWTEST_F(DeviceManagerServiceImplTest, InitOldProtocolAuthMgr_001, testing::ext: ret = deviceManagerServiceImpl_->InitOldProtocolAuthMgr(tokenId, pkgName); EXPECT_EQ(ret, DM_OK); } - -// HWTEST_F(DeviceManagerServiceImplTest, HandleStopPublishService_001, testing::ext::TestSize.Level1) { -// int64_t serviceId = 123456; -// ServiceInfoProfile serviceInfoProfile; -// serviceInfoProfile.publishState = 1; - -// EXPECT_CALL(*deviceProfileConnectorMock_, GetServiceInfoProfileByServiceId(serviceId, _)) -// .WillOnce(DoAll(SetArgReferee<1>(serviceInfoProfile), Return(DM_OK))); -// EXPECT_CALL(*deviceProfileConnectorMock_, PutServiceInfoProfile(_)).Times(1); - -// std::vector profiles; -// AccessControlProfile profile; -// JsonObject extraData; -// extraData[SERVICE_ID_KEY] = serviceId; -// profile.SetExtraData(extraData.Dump()); -// profiles.push_back(profile); -// EXPECT_CALL(*deviceProfileConnectorMock_, GetAllAccessControlProfile()) -// .WillOnce(Return(profiles)); -// EXPECT_CALL(*deviceProfileConnectorMock_, UpdateAccessControlProfile(_)).Times(1); - -// deviceManagerServiceImpl_->HandleStopPublishService(serviceId); - -// EXPECT_EQ(serviceInfoProfile.publishState, PUBLISH_STATE_UNPUBLISHED); -// } - -// HWTEST_F(DeviceManagerServiceImplTest, HandleStopPublishService_002, testing::ext::TestSize.Level1) { -// int64_t serviceId = 654321; - -// EXPECT_CALL(*deviceProfileConnectorMock_, GetServiceInfoProfileByServiceId(serviceId, _)) -// .WillOnce(Return(ERR_DM_FAILED)); -// EXPECT_CALL(*deviceProfileConnectorMock_, PutServiceInfoProfile(_)).Times(0); -// EXPECT_CALL(*deviceProfileConnectorMock_, GetAllAccessControlProfile()).Times(0); -// EXPECT_CALL(*deviceProfileConnectorMock_, UpdateAccessControlProfile(_)).Times(0); - -// deviceManagerServiceImpl_->HandleStopPublishService(serviceId); -// } } // namespace } // namespace DistributedHardware } // namespace OHOS diff --git a/test/unittest/UTTest_device_manager_service_listener.cpp b/test/unittest/UTTest_device_manager_service_listener.cpp index 86b27491c..383b0184d 100644 --- a/test/unittest/UTTest_device_manager_service_listener.cpp +++ b/test/unittest/UTTest_device_manager_service_listener.cpp @@ -17,20 +17,20 @@ #include #include -#include "ipc_server_listener_mock.h" +#include "app_manager.h" #include "dm_anonymous.h" #include "dm_constants.h" #include "dm_device_info.h" #include "dm_log.h" +#include "device_manager_service_notify.h" #include "ipc_notify_auth_result_req.h" #include "ipc_notify_device_found_req.h" #include "ipc_notify_device_state_req.h" #include "ipc_notify_discover_result_req.h" #include "ipc_notify_publish_result_req.h" -#include "device_manager_service_notify.h" -#include "app_manager.h" #include "ipc_service_publish_result_req.h" +#include "ipc_server_listener_mock.h" using namespace testing; using namespace testing::ext; @@ -1145,9 +1145,6 @@ HWTEST_F(DeviceManagerServiceListenerTest, OnServicePublishResult_002, testing:: listener_->OnServicePublishResult(processInfo, serviceId, publishResult); } - - - } // namespace } // namespace DistributedHardware } // namespace OHOS diff --git a/test/unittest/UTTest_device_manager_utils.cpp b/test/unittest/UTTest_device_manager_utils.cpp index 0b554f6a9..cb3fd558c 100644 --- a/test/unittest/UTTest_device_manager_utils.cpp +++ b/test/unittest/UTTest_device_manager_utils.cpp @@ -12,14 +12,13 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#include "UTTest_device_manager_utils.h" #include "common_event_support.h" #include "dm_account_common_event.h" #include "dm_constants.h" #include "matching_skills.h" #include "system_ability_definition.h" - +#include "UTTest_device_manager_utils.h" namespace OHOS { namespace DistributedHardware { std::unordered_map> g_servicePublishCallbackMap; diff --git a/test/unittest/UTTest_device_manager_utils.h b/test/unittest/UTTest_device_manager_utils.h index 56b10f750..5cde41358 100644 --- a/test/unittest/UTTest_device_manager_utils.h +++ b/test/unittest/UTTest_device_manager_utils.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2024 Huawei Device Co., Ltd. + * 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 @@ -19,15 +19,12 @@ #include #include #include - -#include "common_event_support.h" -#include "app_manager_mock.h" -#include "multiple_user_connector_mock.h" -#include "deviceprofile_connector_mock.h" - #include #include - +#include "app_manager_mock.h" +#include "common_event_support.h" +#include "deviceprofile_connector_mock.h" +#include "multiple_user_connector_mock.h" #include "../../interfaces/cj/kits/include/device_manager_impl.h" namespace OHOS { diff --git a/test/unittest/device_manager_impl_test.cpp b/test/unittest/device_manager_impl_test.cpp index 84674aa4b..b3e94732b 100644 --- a/test/unittest/device_manager_impl_test.cpp +++ b/test/unittest/device_manager_impl_test.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022 Huawei Device Co., Ltd. + * 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 diff --git a/test/unittest/device_manager_impl_test.h b/test/unittest/device_manager_impl_test.h index c62b1dbaa..6f309afb1 100644 --- a/test/unittest/device_manager_impl_test.h +++ b/test/unittest/device_manager_impl_test.h @@ -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 @@ -18,16 +18,14 @@ #include #include - #include "device_manager.h" #include "device_manager_callback.h" #include "device_manager_impl.h" -#include "mock/mock_ipc_client_proxy.h" #include "dm_device_info.h" #include "dm_subscribe_info.h" #include "device_manager_notify.h" #include "dm_publish_info.h" - +#include "mock/mock_ipc_client_proxy.h" namespace OHOS { namespace DistributedHardware { class DeviceManagerImplTest : public testing::Test { diff --git a/test/unittest/mock/device_manager_service_impl_mock.h b/test/unittest/mock/device_manager_service_impl_mock.h index 92921e063..d0d5654d4 100644 --- a/test/unittest/mock/device_manager_service_impl_mock.h +++ b/test/unittest/mock/device_manager_service_impl_mock.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2024 Huawei Device Co., Ltd. + * 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 -- Gitee From dc2af093c29e165f3360a8a6621323c3bc5e9f36 Mon Sep 17 00:00:00 2001 From: wym <14509651+i-know-what-to-do@user.noreply.gitee.com> Date: Wed, 27 Aug 2025 14:12:43 +0800 Subject: [PATCH 08/12] DM_TDD --- .../devicemanagerserviceimpl_fuzzer/project.xml | 2 +- .../devicemanagerservicelistener_fuzzer/project.xml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/test/servicesfuzztest/devicemanagerserviceimpl_fuzzer/project.xml b/test/servicesfuzztest/devicemanagerserviceimpl_fuzzer/project.xml index 27c26d11b..500f6f414 100644 --- a/test/servicesfuzztest/devicemanagerserviceimpl_fuzzer/project.xml +++ b/test/servicesfuzztest/devicemanagerserviceimpl_fuzzer/project.xml @@ -1,5 +1,5 @@ -