diff --git a/test/commonunittest/UTTest_dm_auth_manager_first.cpp b/test/commonunittest/UTTest_dm_auth_manager_first.cpp index b9afe71afdb323d9dfd6603d474c0ffa32aaa24a..7c563bde9a22eb741113a7fec82de2d4bc9cdcca 100644 --- a/test/commonunittest/UTTest_dm_auth_manager_first.cpp +++ b/test/commonunittest/UTTest_dm_auth_manager_first.cpp @@ -776,7 +776,7 @@ HWTEST_F(DmAuthManagerTest, ResponseCredential001, testing::ext::TestSize.Level0 authManager_->ResponseCredential(); ASSERT_EQ(authManager_->isAuthDevice_, false); - authManager_->authResponseContext_->publicKey == "publicKey"; + authManager_->authResponseContext_->publicKey = "publicKey"; EXPECT_CALL(*hiChainAuthConnectorMock_, ImportCredential(_, _, _)).WillOnce(Return(ERR_DM_FAILED)); ASSERT_EQ(authManager_->isAuthDevice_, false); @@ -1944,6 +1944,23 @@ HWTEST_F(DmAuthManagerTest, RegisterAuthenticationType_001, testing::ext::TestSi authManager_->authResponseState_ = std::make_shared(); authManager_->ProcessReqPublicKey(); } + +HWTEST_F(DmAuthManagerTest, CheckProcessNameInWhiteList_001, testing::ext::TestSize.Level0) +{ + std::string processName = ""; + bool ret = authManager_->CheckProcessNameInWhiteList(processName); + ASSERT_FALSE(ret); + + processName = "processName"; + ret = authManager_->CheckProcessNameInWhiteList(processName); + ASSERT_FALSE(ret); + + processName = "com.example.myapplication"; + ret = authManager_->CheckProcessNameInWhiteList(processName); + ASSERT_TRUE(ret); +} + + } // namespace } // namespace DistributedHardware } // namespace OHOS diff --git a/test/softbusunittest/UTTest_softbus_listener.cpp b/test/softbusunittest/UTTest_softbus_listener.cpp index 4607adbde725b9e82d2412009a782e4b6245f37c..12b9bb8d3c5a1f6a14c74fc2554df25f32345e0f 100644 --- a/test/softbusunittest/UTTest_softbus_listener.cpp +++ b/test/softbusunittest/UTTest_softbus_listener.cpp @@ -30,6 +30,8 @@ #include "softbus_listener.cpp" #include "softbus_error_code.h" +using namespace testing; +using namespace testing::ext; namespace OHOS { namespace DistributedHardware { void SoftbusListenerTest::SetUp() @@ -40,9 +42,19 @@ void SoftbusListenerTest::TearDown() } void SoftbusListenerTest::SetUpTestCase() { + DistributedDeviceProfile::DpDistributedDeviceProfileClient::dpDistributedDeviceProfileClient = + distributedDeviceProfileClientMock_; + DmCrypto::dmCrypto = cryptoMock_; + DmSoftbusCache::dmSoftbusCache = softbusCacheMock_; } void SoftbusListenerTest::TearDownTestCase() { + DistributedDeviceProfile::DpDistributedDeviceProfileClient::dpDistributedDeviceProfileClient = nullptr; + distributedDeviceProfileClientMock_ = nullptr; + DmCrypto::dmCrypto = nullptr; + cryptoMock_ = nullptr; + DmSoftbusCache::dmSoftbusCache = nullptr; + softbusCacheMock_ = nullptr; } namespace { @@ -314,6 +326,7 @@ HWTEST_F(SoftbusListenerTest, GetUdidByNetworkId_001, testing::ext::TestSize.Lev if (softbusListener == nullptr) { softbusListener = std::make_shared(); } + EXPECT_CALL(*softbusCacheMock_, GetUdidFromCache(_, _)).WillOnce(Return(SOFTBUS_INVALID_PARAM)); int32_t ret = softbusListener->GetUdidByNetworkId(networkId.c_str(), udid); EXPECT_EQ(true, checkSoftbusRes(ret)); } @@ -325,6 +338,7 @@ HWTEST_F(SoftbusListenerTest, GetUuidByNetworkId_001, testing::ext::TestSize.Lev if (softbusListener == nullptr) { softbusListener = std::make_shared(); } + EXPECT_CALL(*softbusCacheMock_, GetUuidFromCache(_, _)).WillOnce(Return(SOFTBUS_INVALID_PARAM)); int32_t ret = softbusListener->GetUuidByNetworkId(networkId.c_str(), udid); EXPECT_EQ(true, checkSoftbusRes(ret)); } @@ -798,6 +812,7 @@ HWTEST_F(SoftbusListenerTest, GetLocalDeviceInfo_001, testing::ext::TestSize.Lev if (softbusListener == nullptr) { softbusListener = std::make_shared(); } + EXPECT_CALL(*softbusCacheMock_, GetLocalDeviceInfo(_)).WillOnce(Return(SOFTBUS_INVALID_PARAM)); int32_t ret = softbusListener->GetLocalDeviceInfo(info); EXPECT_EQ(true, checkSoftbusRes(ret)); } @@ -1040,6 +1055,7 @@ HWTEST_F(SoftbusListenerTest, GetNetworkIdByUdid_001, testing::ext::TestSize.Lev if (softbusListener == nullptr) { softbusListener = std::make_shared(); } + EXPECT_CALL(*softbusCacheMock_, GetNetworkIdFromCache(_, _)).WillOnce(Return(ERR_DM_FAILED)); int32_t ret = softbusListener->GetNetworkIdByUdid(udid, networkId); EXPECT_EQ(ret, ERR_DM_FAILED); } @@ -1073,6 +1089,103 @@ HWTEST_F(SoftbusListenerTest, SetForegroundUserIdsToDSoftBus_001, testing::ext:: softbusListener->OnCredentialAuthStatus(devicelist, deviceListLen, deviceTypeId, errcode); softbusListener = nullptr; } + +HWTEST_F(SoftbusListenerTest, GetUdidFromDp_001, testing::ext::TestSize.Level0) +{ + std::string udidHash = "udidHash"; + std::string udid = "udid"; + if (softbusListener == nullptr) { + softbusListener = std::make_shared(); + } + EXPECT_CALL(*distributedDeviceProfileClientMock_, GetAllAccessControlProfile(_)).WillOnce(Return(ERR_DM_FAILED)); + int32_t ret = softbusListener->GetUdidFromDp(udidHash, udid); + EXPECT_EQ(ret, ERR_DM_FAILED); + + std::vector allProfile; + DistributedDeviceProfile::AccessControlProfile profile; + profile.SetBindType(1); + allProfile.push_back(profile); + EXPECT_CALL(*distributedDeviceProfileClientMock_, GetAllAccessControlProfile(_)) + .WillOnce(DoAll(SetArgReferee<0>(allProfile), Return(DM_OK))); + ret = softbusListener->GetUdidFromDp(udidHash, udid); + EXPECT_EQ(ret, ERR_DM_FAILED); + + profile.SetBindType(2); + profile.SetTrustDeviceId("trustDeviceId"); + allProfile.push_back(profile); + EXPECT_CALL(*distributedDeviceProfileClientMock_, GetAllAccessControlProfile(_)) + .WillOnce(DoAll(SetArgReferee<0>(allProfile), Return(DM_OK))); + EXPECT_CALL(*cryptoMock_, GetUdidHash(_, _)).Times(::testing::AtLeast(1)).WillOnce(Return(ERR_DM_FAILED)); + ret = softbusListener->GetUdidFromDp(udidHash, udid); + EXPECT_EQ(ret, ERR_DM_FAILED); + + EXPECT_CALL(*distributedDeviceProfileClientMock_, GetAllAccessControlProfile(_)) + .WillOnce(DoAll(SetArgReferee<0>(allProfile), Return(DM_OK))); + EXPECT_CALL(*cryptoMock_, GetUdidHash(_, _)).Times(::testing::AtLeast(1)).WillOnce(Return(DM_OK)); + ret = softbusListener->GetUdidFromDp(udidHash, udid); + EXPECT_EQ(ret, ERR_DM_FAILED); +} + +HWTEST_F(SoftbusListenerTest, SetLocalDisplayName_001, testing::ext::TestSize.Level0) +{ + std::string displayName = "displayName"; + if (softbusListener == nullptr) { + softbusListener = std::make_shared(); + } + int32_t ret = softbusListener->SetLocalDisplayName(displayName); + EXPECT_EQ(ret, DM_OK); + std::vector onlineDevInfoVec; + EXPECT_CALL(*softbusCacheMock_, GetDeviceInfoFromCache(_)).Times(::testing::AtLeast(1)) + .WillOnce(DoAll(SetArgReferee<0>(onlineDevInfoVec), Return(DM_OK))); + softbusListener->DeleteCacheDeviceInfo(); + + DmDeviceInfo dmDeviceInfo; + dmDeviceInfo.authForm = DmAuthForm::ACROSS_ACCOUNT; + dmDeviceInfo.deviceTypeId = 1; + onlineDevInfoVec.push_back(dmDeviceInfo); + EXPECT_CALL(*softbusCacheMock_, GetDeviceInfoFromCache(_)).Times(::testing::AtLeast(1)) + .WillOnce(DoAll(SetArgReferee<0>(onlineDevInfoVec), Return(DM_OK))); + softbusListener->DeleteCacheDeviceInfo(); + + DistributedDeviceProfile::AccessControlProfile profile; + DmDeviceInfo deviceInfo; + EXPECT_CALL(*cryptoMock_, GetUdidHash(_, _)).Times(::testing::AtLeast(1)).WillOnce(Return(ERR_DM_FAILED)); + softbusListener->ConvertAclToDeviceInfo(profile, deviceInfo); + + EXPECT_CALL(*cryptoMock_, GetUdidHash(_, _)).Times(::testing::AtLeast(1)).WillOnce(Return(DM_OK)); + EXPECT_CALL(*softbusCacheMock_, GetNetworkIdFromCache(_, _)).Times(::testing::AtLeast(1)).WillOnce(Return(DM_OK)); + softbusListener->ConvertAclToDeviceInfo(profile, deviceInfo); + + EXPECT_CALL(*cryptoMock_, GetUdidHash(_, _)).Times(::testing::AtLeast(1)).WillOnce(Return(DM_OK)); + EXPECT_CALL(*softbusCacheMock_, GetNetworkIdFromCache(_, _)).WillOnce(Return(ERR_DM_FAILED)); + EXPECT_CALL(*softbusCacheMock_, GetDeviceNameFromCache(_, _)).WillOnce(Return(DM_OK)); + softbusListener->ConvertAclToDeviceInfo(profile, deviceInfo); + + EXPECT_CALL(*cryptoMock_, GetUdidHash(_, _)).Times(::testing::AtLeast(1)).WillOnce(Return(DM_OK)); + EXPECT_CALL(*softbusCacheMock_, GetNetworkIdFromCache(_, _)).WillOnce(Return(ERR_DM_FAILED)); + EXPECT_CALL(*softbusCacheMock_, GetDeviceNameFromCache(_, _)).WillOnce(Return(ERR_DM_FAILED)); + softbusListener->ConvertAclToDeviceInfo(profile, deviceInfo); + softbusListener = nullptr; +} + +HWTEST_F(SoftbusListenerTest, GetAllTrustedDeviceList_001, testing::ext::TestSize.Level0) +{ + std::string pkgName = "pkgName"; + std::string extra = "extra"; + std::vector deviceList; + if (softbusListener == nullptr) { + softbusListener = std::make_shared(); + } + std::vector allProfile; + DistributedDeviceProfile::AccessControlProfile profile; + profile.SetBindType(1); + allProfile.push_back(profile); + EXPECT_CALL(*distributedDeviceProfileClientMock_, GetAllAccessControlProfile(_)) + .WillOnce(DoAll(SetArgReferee<0>(allProfile), Return(DM_OK))); + int32_t ret = softbusListener->GetAllTrustedDeviceList(pkgName, extra, deviceList); + EXPECT_EQ(ret, DM_OK); + softbusListener = nullptr; +} } // namespace } // namespace DistributedHardware } // namespace OHOS \ No newline at end of file diff --git a/test/softbusunittest/UTTest_softbus_listener.h b/test/softbusunittest/UTTest_softbus_listener.h index f840ea9e72dd0cd545c7792a3d84389d34eda227..59fa7a9767db147739e2fd9ebd10de18caa65dc5 100644 --- a/test/softbusunittest/UTTest_softbus_listener.h +++ b/test/softbusunittest/UTTest_softbus_listener.h @@ -29,6 +29,9 @@ #include "dm_subscribe_info.h" #include "inner_session.h" #include "session.h" +#include "distributed_device_profile_client_mock.h" +#include "dm_crypto_mock.h" +#include "dm_softbus_cache_mock.h" namespace OHOS { namespace DistributedHardware { @@ -38,6 +41,11 @@ public: static void TearDownTestCase(); void SetUp(); void TearDown(); + static inline std::shared_ptr + distributedDeviceProfileClientMock_ = + std::make_shared(); + static inline std::shared_ptr cryptoMock_ = std::make_shared(); + static inline std::shared_ptr softbusCacheMock_ = std::make_shared(); }; class ISoftbusDiscoveringCallbackTest : public ISoftbusDiscoveringCallback { diff --git a/test/unittest/BUILD.gn b/test/unittest/BUILD.gn index d47d3f153d1ddec39c957c5268e92ee68f733e52..258dc25280f90b321e29f42fe5ea6f29510238f4 100644 --- a/test/unittest/BUILD.gn +++ b/test/unittest/BUILD.gn @@ -589,6 +589,9 @@ ohos_unittest("UTTest_softbus_listener") { sources = [ "${devicemanager_path}/test/softbusunittest/UTTest_softbus_listener.cpp", "${devicemanager_path}/test/unittest/mock/parameter.cpp", + "mock/distributed_device_profile_client_mock.cpp", + "mock/dm_crypto_mock.cpp", + "mock/dm_softbus_cache_mock.cpp", ] deps = [ ":device_manager_test_common" ] @@ -601,6 +604,7 @@ ohos_unittest("UTTest_softbus_listener") { "dsoftbus:softbus_client", "ffrt:libffrt", "googletest:gmock", + "googletest:gmock_main", "hisysevent:libhisysevent", "hitrace:hitrace_meter", ] diff --git a/test/unittest/UTTest_device_manager_impl_two.cpp b/test/unittest/UTTest_device_manager_impl_two.cpp index c28495417f2becbc4596bcbc4a180bc98cb907ac..ea0aa57f4241a00f207a7fbc49242b5e2287ae8a 100644 --- a/test/unittest/UTTest_device_manager_impl_two.cpp +++ b/test/unittest/UTTest_device_manager_impl_two.cpp @@ -2296,6 +2296,54 @@ HWTEST_F(DeviceManagerImplTest, GetNetworkIdByUdid_202, testing::ext::TestSize.L callbackMap[DmCommonNotifyEvent::REG_DEVICE_SCREEN_STATE] = strSet; DeviceManagerImpl::GetInstance().SyncCallbacksToService(callbackMap); } + +HWTEST_F(DeviceManagerImplTest, PutDeviceProfileInfoList_201, testing::ext::TestSize.Level0) +{ + std::string pkgName = "pkgName"; + std::vector deviceProfileInfoList; + std::shared_ptr mockInstance = std::make_shared(); + std::shared_ptr ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_; + DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance; + EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_)) + .Times(1).WillOnce(testing::Return(ERR_DM_IPC_SEND_REQUEST_FAILED)); + int32_t ret = DeviceManager::GetInstance().PutDeviceProfileInfoList(pkgName, deviceProfileInfoList); + ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); + DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy; +} + +HWTEST_F(DeviceManagerImplTest, PutDeviceProfileInfoList_202, testing::ext::TestSize.Level0) +{ + std::string pkgName = "pkgName"; + std::vector deviceProfileInfoList; + std::shared_ptr mockInstance = std::make_shared(); + std::shared_ptr ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_; + DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance; + EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_)) + .Times(1).WillOnce(testing::Return(DM_OK)); + int32_t ret = DeviceManager::GetInstance().PutDeviceProfileInfoList(pkgName, deviceProfileInfoList); + ASSERT_EQ(ret, DM_OK); + DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy; +} + +HWTEST_F(DeviceManagerImplTest, GetLocalDisplayDeviceName_201, testing::ext::TestSize.Level0) +{ + std::string pkgName = "pkgName"; + int32_t maxNameLength = 1; + std::string displayName = "displayName"; + std::shared_ptr mockInstance = std::make_shared(); + std::shared_ptr ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_; + DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance; + EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_)) + .Times(1).WillOnce(testing::Return(ERR_DM_IPC_SEND_REQUEST_FAILED)); + int32_t ret = DeviceManager::GetInstance().GetLocalDisplayDeviceName(pkgName, maxNameLength, displayName); + ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED); + + EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_)) + .Times(1).WillOnce(testing::Return(DM_OK)); + ret = DeviceManager::GetInstance().GetLocalDisplayDeviceName(pkgName, maxNameLength, displayName); + ASSERT_EQ(ret, DM_OK); + DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy; +} } // namespace } // namespace DistributedHardware } // namespace OHOS diff --git a/test/unittest/UTTest_device_manager_service_two.cpp b/test/unittest/UTTest_device_manager_service_two.cpp index 56e8d168dadbeb80945c52d48d2322af74668257..7e4fb020fa5fdf61f1b5696896c84eb245c6b99a 100644 --- a/test/unittest/UTTest_device_manager_service_two.cpp +++ b/test/unittest/UTTest_device_manager_service_two.cpp @@ -1288,6 +1288,66 @@ HWTEST_F(DeviceManagerServiceTest, GetDeviceIconInfo_202, testing::ext::TestSize int32_t ret = DeviceManagerService::GetInstance().GetDeviceIconInfo(pkgName, filterOptions); EXPECT_EQ(ret, ERR_DM_UNSUPPORTED_METHOD); } + +HWTEST_F(DeviceManagerServiceTest, PutDeviceProfileInfoList_201, testing::ext::TestSize.Level0) +{ + DeletePermission(); + std::string pkgName = "pkgName"; + std::vector deviceProfileInfoList; + int32_t ret = DeviceManagerService::GetInstance().PutDeviceProfileInfoList(pkgName, deviceProfileInfoList); + EXPECT_EQ(ret, ERR_DM_NO_PERMISSION); +} + +HWTEST_F(DeviceManagerServiceTest, PutDeviceProfileInfoList_202, testing::ext::TestSize.Level0) +{ + std::string pkgName = "pkgName"; + std::vector deviceProfileInfoList; + int32_t ret = DeviceManagerService::GetInstance().PutDeviceProfileInfoList(pkgName, deviceProfileInfoList); + EXPECT_EQ(ret, ERR_DM_UNSUPPORTED_METHOD); +} + +HWTEST_F(DeviceManagerServiceTest, SetLocalDisplayNameToSoftbus_201, testing::ext::TestSize.Level0) +{ + std::string displayName = "displayName"; + DeviceManagerService::GetInstance().softbusListener_ = nullptr; + int32_t ret = DeviceManagerService::GetInstance().SetLocalDisplayNameToSoftbus(displayName); + EXPECT_EQ(ret, ERR_DM_POINT_NULL); + + DeviceManagerService::GetInstance().softbusListener_ = std::make_shared(); + EXPECT_CALL(*softbusListenerMock_, SetLocalDisplayName(_)).WillOnce(Return(DM_OK)); + ret = DeviceManagerService::GetInstance().SetLocalDisplayNameToSoftbus(displayName); + EXPECT_EQ(ret, DM_OK); + + EXPECT_CALL(*softbusListenerMock_, SetLocalDisplayName(_)).WillOnce(Return(ERR_DM_NO_PERMISSION)); + ret = DeviceManagerService::GetInstance().SetLocalDisplayNameToSoftbus(displayName); + EXPECT_EQ(ret, ERR_DM_NO_PERMISSION); + DeviceManagerService::GetInstance().softbusListener_ = nullptr; +} + +HWTEST_F(DeviceManagerServiceTest, GetLocalDisplayDeviceName_201, testing::ext::TestSize.Level0) +{ + DeletePermission(); + std::string pkgName = "packName"; + int32_t maxNameLength = 1; + std::string displayName = "displayName"; + int32_t ret = DeviceManagerService::GetInstance().GetLocalDisplayDeviceName(pkgName, maxNameLength, displayName); + EXPECT_EQ(ret, ERR_DM_NO_PERMISSION); +} + +HWTEST_F(DeviceManagerServiceTest, GetLocalDisplayDeviceName_202, testing::ext::TestSize.Level0) +{ + std::string pkgName = "packName"; + int32_t maxNameLength = 1; + std::string displayName = "displayName"; + int32_t ret = DeviceManagerService::GetInstance().GetLocalDisplayDeviceName(pkgName, maxNameLength, displayName); + EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID); +} + +HWTEST_F(DeviceManagerServiceTest, GetDeviceNamePrefixs_201, testing::ext::TestSize.Level0) +{ + auto ret = DeviceManagerService::GetInstance().GetDeviceNamePrefixs(); + EXPECT_EQ(ret.empty(), true); +} } // namespace } // namespace DistributedHardware } // namespace OHOS diff --git a/test/unittest/mock/dm_crypto_mock.cpp b/test/unittest/mock/dm_crypto_mock.cpp index f6cf4713dedf1f89d9cccad71da6d0aa01b4b1eb..a559c2d01f8d96feaa07544eb0b3437d0b1e8fc1 100644 --- a/test/unittest/mock/dm_crypto_mock.cpp +++ b/test/unittest/mock/dm_crypto_mock.cpp @@ -19,6 +19,8 @@ namespace OHOS { namespace DistributedHardware { + + int32_t Crypto::GetAccountIdHash(const std::string &accountId, unsigned char *accountIdHash) { return DmCrypto::dmCrypto->GetAccountIdHash(accountId, accountIdHash); diff --git a/test/unittest/mock/dm_softbus_cache_mock.cpp b/test/unittest/mock/dm_softbus_cache_mock.cpp index ca401d4f507b30c7e26ab9843441e141f2116b7a..322fa94994ab7bd5ef99b42c9e90bac8701bf7ad 100644 --- a/test/unittest/mock/dm_softbus_cache_mock.cpp +++ b/test/unittest/mock/dm_softbus_cache_mock.cpp @@ -54,5 +54,10 @@ int32_t SoftbusCache::GetDeviceInfoFromCache(std::vector &deviceIn { return DmSoftbusCache::dmSoftbusCache->GetDeviceInfoFromCache(deviceInfoList); } + +int32_t SoftbusCache::GetDeviceNameFromCache(const std::string &udid, std::string &deviceName) +{ + return DmSoftbusCache::dmSoftbusCache->GetDeviceNameFromCache(udid, deviceName); +} } // namespace DistributedHardware } // namespace OHOS \ No newline at end of file diff --git a/test/unittest/mock/dm_softbus_cache_mock.h b/test/unittest/mock/dm_softbus_cache_mock.h index adf41876d237e4583a5a2c1782696394d44c9139..1a519e53d7e4f1512b4f70a93fc75ba022b695b8 100644 --- a/test/unittest/mock/dm_softbus_cache_mock.h +++ b/test/unittest/mock/dm_softbus_cache_mock.h @@ -33,6 +33,7 @@ public: virtual int32_t GetUuidFromCache(const char *networkId, std::string &uuid) = 0; virtual bool CheckIsOnline(const std::string &deviceId) = 0; virtual int32_t GetDeviceInfoFromCache(std::vector &deviceInfoList) = 0; + virtual int32_t GetDeviceNameFromCache(const std::string &udid, std::string &deviceName) = 0; public: static inline std::shared_ptr dmSoftbusCache = nullptr; }; @@ -46,6 +47,7 @@ public: MOCK_METHOD(int32_t, GetUuidFromCache, (const char *, std::string &)); MOCK_METHOD(bool, CheckIsOnline, (const std::string &)); MOCK_METHOD(int32_t, GetDeviceInfoFromCache, (std::vector &)); + MOCK_METHOD(int32_t, GetDeviceNameFromCache, (const std::string &, std::string &)); }; } }