• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2022-2025 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include <gtest/gtest.h>
17 #include <securec.h>
18 
19 #include "auth_session_fsm.h"
20 #include "lnn_connection_mock.h"
21 #include "lnn_devicename_info.c"
22 #include "lnn_devicename_info.h"
23 #include "lnn_net_builder.h"
24 #include "lnn_net_ledger_mock.h"
25 #include "lnn_service_mock.h"
26 #include "lnn_sync_info_manager.h"
27 #include "lnn_sync_info_mock.h"
28 #include "softbus_error_code.h"
29 
30 namespace OHOS {
31 using namespace testing;
32 using namespace testing::ext;
33 NodeInfo *info = { 0 };
34 constexpr int64_t ACCOUNT_ID = 10;
35 constexpr char *DEVICE_NAME1 = nullptr;
36 constexpr char DEVICE_NAME2[] = "ABCDEFG";
37 constexpr uint32_t MSG_ERR_LEN0 = 0;
38 constexpr char NODE_UDID[] = "123456ABCDEF";
39 constexpr char NETWORKID[NETWORK_ID_BUF_LEN] = "123456ABD";
40 constexpr char DEVICE_NAME3[] = "";
41 
42 class LNNDeviceNameInfoTest : public testing::Test {
43 public:
44     static void SetUpTestCase();
45     static void TearDownTestCase();
46     void SetUp();
47     void TearDown();
48 };
49 
SetUpTestCase()50 void LNNDeviceNameInfoTest::SetUpTestCase() { }
51 
TearDownTestCase()52 void LNNDeviceNameInfoTest::TearDownTestCase() { }
53 
SetUp()54 void LNNDeviceNameInfoTest::SetUp() { }
55 
TearDown()56 void LNNDeviceNameInfoTest::TearDown() { }
57 
58 /*
59  * @tc.name: ON_RECEIVE_DEVICE_NAME_TEST_001
60  * @tc.desc: on receive device name test
61  * @tc.type: FUNC
62  * @tc.require:
63  */
64 HWTEST_F(LNNDeviceNameInfoTest, ON_RECEIVE_DEVICE_NAME_TEST_001, TestSize.Level1)
65 {
66     char msg[] = "msg";
67     NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
68     NiceMock<LnnServicetInterfaceMock> serviceMock;
69     EXPECT_CALL(ledgerMock, LnnConvertDlId).WillOnce(Return(SOFTBUS_INVALID_PARAM)).WillRepeatedly(Return(SOFTBUS_OK));
70     EXPECT_CALL(ledgerMock, LnnSetDLDeviceInfoName).WillOnce(Return(false)).WillRepeatedly(Return(true));
71     EXPECT_CALL(ledgerMock, LnnGetBasicInfoByUdid)
72         .WillOnce(Return(SOFTBUS_INVALID_PARAM))
73         .WillRepeatedly(Return(SOFTBUS_OK));
74     EXPECT_CALL(ledgerMock, LnnGetRemoteNodeInfoById)
75         .WillOnce(Return(SOFTBUS_INVALID_PARAM))
76         .WillRepeatedly(Return(SOFTBUS_OK));
77     EXPECT_CALL(serviceMock, LnnNotifyBasicInfoChanged).WillRepeatedly(Return());
78     EXPECT_CALL(serviceMock, UpdateProfile).WillRepeatedly(Return());
79     OnReceiveDeviceName(LNN_INFO_TYPE_COUNT, NETWORKID, reinterpret_cast<uint8_t *>(msg), strlen(msg) + 1);
80     OnReceiveDeviceName(LNN_INFO_TYPE_DEVICE_NAME, NETWORKID, reinterpret_cast<uint8_t *>(msg), MSG_ERR_LEN0);
81     OnReceiveDeviceName(LNN_INFO_TYPE_DEVICE_NAME, nullptr, reinterpret_cast<uint8_t *>(msg), strlen(msg) + 1);
82     OnReceiveDeviceName(LNN_INFO_TYPE_DEVICE_NAME, NETWORKID, nullptr, strlen(msg));
83     OnReceiveDeviceName(LNN_INFO_TYPE_DEVICE_NAME, NETWORKID, reinterpret_cast<uint8_t *>(msg), strlen(msg) + 1);
84     OnReceiveDeviceName(LNN_INFO_TYPE_DEVICE_NAME, NETWORKID, reinterpret_cast<uint8_t *>(msg), strlen(msg) + 1);
85     OnReceiveDeviceName(LNN_INFO_TYPE_DEVICE_NAME, NETWORKID, reinterpret_cast<uint8_t *>(msg), strlen(msg) + 1);
86     OnReceiveDeviceName(LNN_INFO_TYPE_DEVICE_NAME, NETWORKID, reinterpret_cast<uint8_t *>(msg), strlen(msg) + 1);
87     OnReceiveDeviceName(LNN_INFO_TYPE_DEVICE_NAME, NETWORKID, reinterpret_cast<uint8_t *>(msg), strlen(msg) + 1);
88 }
89 
90 /*
91  * @tc.name: ON_RECEIVE_DEVICE_NICK_NAME_TEST_001
92  * @tc.desc: on receive device nick name test
93  * @tc.type: FUNC
94  * @tc.require:
95  */
96 HWTEST_F(LNNDeviceNameInfoTest, ON_RECEIVE_DEVICE_NICK_NAME_TEST_001, TestSize.Level1)
97 {
98     NodeInfo nodeInfo;
99     NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
100     EXPECT_CALL(ledgerMock, LnnGetLocalNodeInfo).WillOnce(Return(nullptr)).WillRepeatedly(Return(&nodeInfo));
101     EXPECT_CALL(ledgerMock, LnnGetRemoteNodeInfoById)
102         .WillOnce(Return(SOFTBUS_INVALID_PARAM))
103         .WillRepeatedly(Return(SOFTBUS_OK));
104     char msg1[] = "{\"KEY_NICK_NAME\":\"nickName\"}";
105     char msg2[] = "{\"KEY_ACCOUNT\":10}";
106     char msg3[] = "{\"KEY_ACCOUNT\":10, \"KEY_NICK_NAME\":\"nickName\"}";
107     OnReceiveDeviceNickName(LNN_INFO_TYPE_NICK_NAME, NETWORKID, nullptr, strlen(msg1) + 1);
108     OnReceiveDeviceNickName(LNN_INFO_TYPE_COUNT, NETWORKID, reinterpret_cast<uint8_t *>(msg1), strlen(msg1) + 1);
109     OnReceiveDeviceNickName(LNN_INFO_TYPE_NICK_NAME, NETWORKID, reinterpret_cast<uint8_t *>(msg1), MSG_ERR_LEN0);
110     OnReceiveDeviceNickName(LNN_INFO_TYPE_NICK_NAME, NETWORKID, reinterpret_cast<uint8_t *>(msg1), strlen(msg1) + 1);
111     OnReceiveDeviceNickName(LNN_INFO_TYPE_NICK_NAME, NETWORKID, reinterpret_cast<uint8_t *>(msg2), strlen(msg2) + 1);
112     OnReceiveDeviceNickName(LNN_INFO_TYPE_NICK_NAME, NETWORKID, reinterpret_cast<uint8_t *>(msg3), strlen(msg3) + 1);
113     OnReceiveDeviceNickName(LNN_INFO_TYPE_NICK_NAME, NETWORKID, reinterpret_cast<uint8_t *>(msg3), strlen(msg3) + 1);
114     OnReceiveDeviceNickName(LNN_INFO_TYPE_NICK_NAME, NETWORKID, reinterpret_cast<uint8_t *>(msg3), strlen(msg3) + 1);
115 }
116 
117 /*
118  * @tc.name: LNN_SYNC_DEVICE_NAME_TEST_001
119  * @tc.desc: lnn sync device name test
120  * @tc.type: FUNC
121  * @tc.require:
122  */
123 HWTEST_F(LNNDeviceNameInfoTest, LNN_SYNC_DEVICE_NAME_TEST_001, TestSize.Level1)
124 {
125     NodeInfo nodeInfo;
126     SendSyncInfoParam *data = (SendSyncInfoParam *)SoftBusMalloc(sizeof(SendSyncInfoParam));
127     EXPECT_TRUE(data != nullptr);
128     memset_s(data, sizeof(SendSyncInfoParam), 0, sizeof(SendSyncInfoParam));
129     NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
130     EXPECT_CALL(ledgerMock, LnnGetLocalNodeInfo).WillOnce(Return(nullptr)).WillRepeatedly(Return(&nodeInfo));
131     EXPECT_CALL(ledgerMock, LnnGetDeviceName).WillOnce(Return(DEVICE_NAME1)).WillRepeatedly(Return(DEVICE_NAME2));
132     NiceMock<LnnSyncInfoInterfaceMock> lnnSyncInfoMock;
133     EXPECT_CALL(lnnSyncInfoMock, CreateSyncInfoParam).WillOnce(Return(nullptr)).WillRepeatedly(Return(data));
134     NiceMock<LnnServicetInterfaceMock> ServiceMock;
135     EXPECT_CALL(ServiceMock, LnnAsyncCallbackHelper).WillRepeatedly(Return(SOFTBUS_OK));
136     int32_t ret = LnnSyncDeviceName(NETWORKID);
137     EXPECT_TRUE(ret == SOFTBUS_NETWORK_GET_LOCAL_NODE_INFO_ERR);
138     ret = LnnSyncDeviceName(NETWORKID);
139     EXPECT_TRUE(ret == SOFTBUS_NETWORK_GET_DEVICE_INFO_ERR);
140     ret = LnnSyncDeviceName(NETWORKID);
141     EXPECT_TRUE(ret == SOFTBUS_NETWORK_SEND_SYNC_INFO_FAILED);
142     ret = LnnSyncDeviceName(NETWORKID);
143     EXPECT_TRUE(ret == SOFTBUS_OK);
144     SoftBusFree(data->msg);
145     SoftBusFree(data);
146 }
147 
148 /*
149  * @tc.name: NICK_NAME_MSG_PROC_TEST_001
150  * @tc.desc: nick name msg proc test
151  * @tc.type: FUNC
152  * @tc.require:
153  */
154 HWTEST_F(LNNDeviceNameInfoTest, NICK_NAME_MSG_PROC_TEST_001, TestSize.Level1)
155 {
156     NodeInfo nodeInfo = {
157         .accountId = ACCOUNT_ID + 1,
158     };
159     NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
160     NiceMock<LnnServicetInterfaceMock> serviceMock;
161     EXPECT_CALL(ledgerMock, LnnGetLocalNodeInfo).WillOnce(Return(nullptr)).WillRepeatedly(Return(&nodeInfo));
162     EXPECT_CALL(ledgerMock, LnnSetDLDeviceNickName).WillRepeatedly(Return(SOFTBUS_OK));
163     EXPECT_CALL(ledgerMock, LnnGetBasicInfoByUdid).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
164 
165     NodeInfo peerNodeInfo1 = {
166         .deviceInfo.nickName = "nickName",
167     };
168     NodeInfo peerNodeInfo2 = {
169         .deviceInfo.nickName = "diffNickName",
170         .deviceInfo.unifiedName = "unifiedName",
171         .deviceInfo.unifiedDefaultName = "unifiedDefaultName",
172         .deviceInfo.deviceName = "deviceName",
173     };
174     NodeInfo peerNodeInfo3 = {
175         .deviceInfo.nickName = "diffNickName",
176         .deviceInfo.unifiedName = "",
177         .deviceInfo.unifiedDefaultName = "unifiedDefaultName",
178         .deviceInfo.deviceName = "deviceName",
179     };
180     EXPECT_CALL(ledgerMock, LnnGetRemoteNodeInfoById)
181         .WillOnce(Return(SOFTBUS_INVALID_PARAM))
182         .WillOnce(DoAll(SetArgPointee<2>(peerNodeInfo1), Return(SOFTBUS_OK)))
183         .WillOnce(DoAll(SetArgPointee<2>(peerNodeInfo2), Return(SOFTBUS_OK)))
184         .WillRepeatedly(DoAll(SetArgPointee<2>(peerNodeInfo3), Return(SOFTBUS_OK)));
185     const char *displayName = "";
186     EXPECT_CALL(serviceMock, LnnNotifyBasicInfoChanged).WillRepeatedly(Return());
187     EXPECT_CALL(serviceMock, LnnGetDeviceDisplayName)
188         .WillRepeatedly(DoAll(SetArgPointee<2>(*(const_cast<char *>(displayName))), Return(SOFTBUS_OK)));
189     NickNameMsgProc(NETWORKID, ACCOUNT_ID, "nickName");
190     NickNameMsgProc(NETWORKID, ACCOUNT_ID, "nickName");
191     NickNameMsgProc(NETWORKID, ACCOUNT_ID, "nickName");
192     NickNameMsgProc(NETWORKID, ACCOUNT_ID, "nickName");
193     NickNameMsgProc(NETWORKID, ACCOUNT_ID, "nickName");
194     NickNameMsgProc(NETWORKID, ACCOUNT_ID, "");
195     NickNameMsgProc(NETWORKID, ACCOUNT_ID, "nickName");
196     NickNameMsgProc(NETWORKID, ACCOUNT_ID, "nickName");
197 }
198 
199 /*
200  * @tc.name: NOTIFY_DEVICE_DISPLAY_NAME_CHANGE_TEST_001
201  * @tc.desc: notify device display name change test
202  * @tc.type: FUNC
203  * @tc.require:
204  */
205 HWTEST_F(LNNDeviceNameInfoTest, NOTIFY_DEVICE_DISPLAY_NAME_CHANGE_TEST_001, TestSize.Level1)
206 {
207     NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
208     NiceMock<LnnServicetInterfaceMock> serviceMock;
209     EXPECT_CALL(ledgerMock, LnnGetBasicInfoByUdid)
210         .WillOnce(Return(SOFTBUS_INVALID_PARAM))
211         .WillRepeatedly(Return(SOFTBUS_OK));
212     EXPECT_CALL(ledgerMock, LnnGetRemoteNodeInfoById)
213         .WillOnce(Return(SOFTBUS_INVALID_PARAM))
214         .WillRepeatedly(Return(SOFTBUS_OK));
215     EXPECT_CALL(serviceMock, LnnNotifyBasicInfoChanged).WillRepeatedly(Return());
216     EXPECT_CALL(serviceMock, UpdateProfile).WillRepeatedly(Return());
217     NotifyDeviceDisplayNameChange(NETWORKID, NODE_UDID);
218     NotifyDeviceDisplayNameChange(NETWORKID, NODE_UDID);
219     NotifyDeviceDisplayNameChange(NETWORKID, NODE_UDID);
220 }
221 
222 /*
223  * @tc.name: LNN_INIT_DEVICE_NAME_TEST_001
224  * @tc.desc: LnnInitDevicename test LnnRegSyncInfoHandler return error
225  * @tc.type: FUNC
226  * @tc.require:
227  */
228 HWTEST_F(LNNDeviceNameInfoTest, LNN_INIT_DEVICE_NAME_TEST_001, TestSize.Level1)
229 {
230     NiceMock<LnnSyncInfoInterfaceMock> lnnSyncInfoMock;
231     EXPECT_CALL(lnnSyncInfoMock, LnnRegSyncInfoHandler).WillRepeatedly(Return(SOFTBUS_LOCK_ERR));
232     int32_t ret = LnnInitDevicename();
233     EXPECT_EQ(ret, SOFTBUS_LOCK_ERR);
234 }
235 
236 /*
237  * @tc.name: LNN_INIT_DEVICE_NAME_TEST_002
238  * @tc.desc: LnnInitDevicename test LnnRegSyncInfoHandler return success
239  * @tc.type: FUNC
240  * @tc.require:
241  */
242 HWTEST_F(LNNDeviceNameInfoTest, LNN_INIT_DEVICE_NAME_TEST_002, TestSize.Level1)
243 {
244     NiceMock<LnnSyncInfoInterfaceMock> lnnSyncInfoMock;
245     EXPECT_CALL(lnnSyncInfoMock, LnnRegSyncInfoHandler).WillRepeatedly(Return(SOFTBUS_OK));
246     int32_t ret = LnnInitDevicename();
247     EXPECT_EQ(ret, SOFTBUS_OK);
248 }
249 
250 /*
251  * @tc.name: LNN_SET_LOCAL_DEVICE_NAME_TEST_001
252  * @tc.desc: LnnSetLocalDeviceName test
253  * @tc.type: FUNC
254  * @tc.require:
255  */
256 HWTEST_F(LNNDeviceNameInfoTest, LNN_SET_LOCAL_DEVICE_NAME_TEST_001, TestSize.Level1)
257 {
258     NiceMock<LnnServicetInterfaceMock> serviceMock;
259     EXPECT_CALL(serviceMock, LnnNotifyDeviceInfoChanged).WillRepeatedly(Return());
260     EXPECT_CALL(serviceMock, LnnNotifyLocalNetworkIdChanged).WillRepeatedly(Return());
261     int32_t ret = LnnSetLocalDeviceName(DEVICE_NAME1);
262     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
263     ret = LnnSetLocalDeviceName(DEVICE_NAME3);
264     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
265     NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
266     EXPECT_CALL(ledgerMock, LnnGetLocalStrInfo).WillOnce(Return(SOFTBUS_INVALID_PARAM));
267     ret = LnnSetLocalDeviceName(DEVICE_NAME2);
268     EXPECT_EQ(ret, SOFTBUS_NETWORK_GET_NODE_INFO_ERR);
269     const char *info = "ABCDEFG";
270     EXPECT_CALL(ledgerMock, LnnGetLocalStrInfo).WillOnce(DoAll(SetArgPointee<1>(*info), Return(SOFTBUS_OK)));
271     ret = LnnSetLocalDeviceName(DEVICE_NAME2);
272     EXPECT_EQ(ret, SOFTBUS_OK);
273     const char *info1 = "ABCDEFGHIGKL";
274     EXPECT_CALL(ledgerMock, LnnGetLocalStrInfo).WillRepeatedly(DoAll(SetArgPointee<1>(*info1), Return(SOFTBUS_OK)));
275     EXPECT_CALL(ledgerMock, LnnSetLocalStrInfo)
276         .WillOnce(Return(SOFTBUS_INVALID_PARAM))
277         .WillRepeatedly(Return(SOFTBUS_OK));
278     ret = LnnSetLocalDeviceName(DEVICE_NAME2);
279     EXPECT_EQ(ret, SOFTBUS_NETWORK_SET_NODE_INFO_ERR);
280     EXPECT_CALL(ledgerMock, LnnGetAllOnlineNodeInfo)
281         .WillOnce(Return(SOFTBUS_INVALID_PARAM))
282         .WillRepeatedly(DoAll(SetArgPointee<1>(1), Return(SOFTBUS_OK)));
283     ret = LnnSetLocalDeviceName(DEVICE_NAME2);
284     EXPECT_EQ(ret, SOFTBUS_NETWORK_GET_ALL_NODE_INFO_ERR);
285     EXPECT_CALL(ledgerMock, LnnIsLSANode).WillRepeatedly(Return(true));
286     ret = LnnSetLocalDeviceName(DEVICE_NAME2);
287     EXPECT_EQ(ret, SOFTBUS_OK);
288 }
289 
290 /*
291  * @tc.name: LNN_ASYNC_DEVICE_NAME_DALEY_TEST_001
292  * @tc.desc: lnn Async device name test
293  * @tc.type: FUNC
294  * @tc.require:
295  */
296 HWTEST_F(LNNDeviceNameInfoTest, LNN_ASYNC_DEVICE_NAME_DALEY_TEST_001, TestSize.Level1)
297 {
298     NodeInfo nodeInfo;
299     (void)memset_s(&nodeInfo, sizeof(nodeInfo), 0, sizeof(nodeInfo));
300     SendSyncInfoParam *data = (SendSyncInfoParam *)SoftBusCalloc(sizeof(SendSyncInfoParam));
301     ASSERT_TRUE(data != nullptr);
302     memset_s(data, sizeof(SendSyncInfoParam), 0, sizeof(SendSyncInfoParam));
303 
304     NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
305     EXPECT_CALL(ledgerMock, LnnGetLocalNodeInfo).WillOnce(Return(nullptr)).WillRepeatedly(Return(&nodeInfo));
306     EXPECT_CALL(ledgerMock, LnnGetDeviceName).WillOnce(Return(DEVICE_NAME1)).WillRepeatedly(Return(DEVICE_NAME2));
307     NiceMock<LnnSyncInfoInterfaceMock> lnnSyncInfoMock;
308     EXPECT_CALL(lnnSyncInfoMock, CreateSyncInfoParam).WillOnce(Return(nullptr)).WillRepeatedly(Return(data));
309     NiceMock<LnnServicetInterfaceMock> ServiceMock;
310     EXPECT_CALL(ServiceMock, LnnAsyncCallbackDelayHelper).WillRepeatedly(Return(SOFTBUS_OK));
311 
312     int32_t ret = LnnAsyncDeviceNameDelay(NETWORKID);
313     EXPECT_TRUE(ret == SOFTBUS_NETWORK_GET_LOCAL_NODE_INFO_ERR);
314 
315     ret = LnnAsyncDeviceNameDelay(NETWORKID);
316     EXPECT_TRUE(ret == SOFTBUS_NETWORK_GET_DEVICE_INFO_ERR);
317 
318     ret = LnnAsyncDeviceNameDelay(NETWORKID);
319     EXPECT_TRUE(ret == SOFTBUS_NETWORK_CREATE_SYNC_INFO_PARAM_FAILED);
320 
321     ret = LnnAsyncDeviceNameDelay(NETWORKID);
322     EXPECT_TRUE(ret == SOFTBUS_OK);
323     SoftBusFree(data);
324 }
325 
326 /*
327  * @tc.name: LNN_ASYNC_DEVICE_NAME_DELAY_TEST_001
328  * @tc.desc: LnnAsyncDeviceNameDelay test get info failed
329  * @tc.type: FUNC
330  * @tc.require:
331  */
332 HWTEST_F(LNNDeviceNameInfoTest, LNN_ASYNC_DEVICE_NAME_DELAY_TEST_001, TestSize.Level1)
333 {
334     NodeInfo *nodeInfo = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
335     ASSERT_NE(nodeInfo, nullptr);
336     const char *devName = "deviceNickname";
337     ASSERT_EQ(strncpy_s(nodeInfo->deviceInfo.deviceName, DEVICE_NAME_BUF_LEN, devName, strlen(devName)), EOK);
338     NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
339     EXPECT_CALL(ledgerMock, LnnGetLocalNodeInfo).WillOnce(Return(nullptr)).WillRepeatedly(Return(nodeInfo));
340     EXPECT_CALL(ledgerMock, LnnGetDeviceName).WillOnce(Return(nullptr)).WillRepeatedly(Return(devName));
341     NiceMock<LnnSyncInfoInterfaceMock> lnnSyncInfoMock;
342     int32_t ret = LnnAsyncDeviceNameDelay(NETWORKID);
343     EXPECT_EQ(ret, SOFTBUS_NETWORK_GET_LOCAL_NODE_INFO_ERR);
344     ret = LnnAsyncDeviceNameDelay(NETWORKID);
345     EXPECT_EQ(ret, SOFTBUS_NETWORK_GET_DEVICE_INFO_ERR);
346     ret = LnnAsyncDeviceNameDelay(NETWORKID);
347     EXPECT_EQ(ret, SOFTBUS_NETWORK_CREATE_SYNC_INFO_PARAM_FAILED);
348     SoftBusFree(nodeInfo);
349 }
350 
351 /*
352 * @tc.name: LNN_ASYNC_DEVICE_NAME_DELAY_TEST_002
353 * @tc.desc: LnnAsyncDeviceNameDelay test send sync info failed
354 * @tc.type: FUNC
355 * @tc.require:
356 */
357 HWTEST_F(LNNDeviceNameInfoTest, LNN_ASYNC_DEVICE_NAME_DELAY_TEST_002, TestSize.Level1)
358 {
359     NodeInfo *nodeInfo = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
360     ASSERT_NE(nodeInfo, nullptr);
361     const char *devName = "deviceNickname";
362     SendSyncInfoParam *data = (SendSyncInfoParam *)SoftBusCalloc(sizeof(SendSyncInfoParam));
363     ASSERT_NE(data, nullptr);
364     NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
365     EXPECT_CALL(ledgerMock, LnnGetLocalNodeInfo).WillRepeatedly(Return(nodeInfo));
366     EXPECT_CALL(ledgerMock, LnnGetDeviceName).WillRepeatedly(Return(devName));
367     NiceMock<LnnSyncInfoInterfaceMock> lnnSyncInfoMock;
368     NiceMock<LnnServicetInterfaceMock> ServiceMock;
369     EXPECT_CALL(lnnSyncInfoMock, CreateSyncInfoParam).WillRepeatedly(Return(data));
370     EXPECT_CALL(ServiceMock, LnnAsyncCallbackDelayHelper).WillRepeatedly(Return(SOFTBUS_NETWORK_SEND_SYNC_INFO_FAILED));
371     int32_t ret = LnnAsyncDeviceNameDelay(NETWORKID);
372     EXPECT_EQ(ret, SOFTBUS_NETWORK_SEND_SYNC_INFO_FAILED);
373     SoftBusFree(nodeInfo);
374 }
375 
376 /*
377  * @tc.name: LNN_ASYNC_DEVICE_NAME_DELAY_TEST_003
378  * @tc.desc: LnnAsyncDeviceNameDelay test get nodeInfo success
379  * @tc.type: FUNC
380  * @tc.require:
381  */
382 HWTEST_F(LNNDeviceNameInfoTest, LNN_ASYNC_DEVICE_NAME_DELAY_TEST_003, TestSize.Level1)
383 {
384     NodeInfo *nodeInfo = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
385     ASSERT_NE(nodeInfo, nullptr);
386     const char *devName = "deviceNickname";
387     SendSyncInfoParam *data = (SendSyncInfoParam *)SoftBusCalloc(sizeof(SendSyncInfoParam));
388     ASSERT_NE(data, nullptr);
389     NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
390     EXPECT_CALL(ledgerMock, LnnGetLocalNodeInfo).WillRepeatedly(Return(nodeInfo));
391     EXPECT_CALL(ledgerMock, LnnGetDeviceName).WillRepeatedly(Return(devName));
392     NiceMock<LnnSyncInfoInterfaceMock> lnnSyncInfoMock;
393     NiceMock<LnnServicetInterfaceMock> ServiceMock;
394     EXPECT_CALL(lnnSyncInfoMock, CreateSyncInfoParam).WillRepeatedly(Return(data));
395     EXPECT_CALL(ServiceMock, LnnAsyncCallbackDelayHelper).WillRepeatedly(Return(SOFTBUS_OK));
396     int32_t ret = LnnAsyncDeviceNameDelay(NETWORKID);
397     EXPECT_EQ(ret, SOFTBUS_OK);
398     SoftBusFree(nodeInfo);
399     SoftBusFree(data);
400 }
401 
402 /*
403  * @tc.name: LNN_SET_DISPLAY_NAME_TEST_001
404  * @tc.desc: LnnSetDisplayName test
405  * @tc.type: FUNC
406  * @tc.require:
407  */
408 HWTEST_F(LNNDeviceNameInfoTest, LNN_SET_DISPLAY_NAME_TEST_001, TestSize.Level1)
409 {
410     NodeInfo peerNodeInfo = {
411         .deviceInfo.nickName = "diffNickName",
412         .deviceInfo.unifiedName = "unifiedName",
413         .deviceInfo.unifiedDefaultName = "unifiedDefaultName",
414         .deviceInfo.deviceName = "deviceName",
415     };
416     NodeInfo localNodeInfo = {
417         .deviceInfo.nickName = "diffNickName",
418         .deviceInfo.unifiedName = "",
419         .deviceInfo.unifiedDefaultName = "unifiedDefaultName",
420         .deviceInfo.deviceName = "deviceName",
421         .accountId = ACCOUNT_ID,
422     };
423     NiceMock<LnnServicetInterfaceMock> serviceMock;
424     EXPECT_CALL(serviceMock, LnnGetDeviceDisplayName).WillRepeatedly(Return(SOFTBUS_OK));
425     char displayName[] = "displayName";
426     const char *nickName = "";
427     int64_t accountId = ACCOUNT_ID;
428     EXPECT_NO_FATAL_FAILURE(LnnSetDisplayName(displayName, nickName, &peerNodeInfo, &localNodeInfo, accountId));
429     EXPECT_EQ(EOK, strcpy_s(peerNodeInfo.deviceInfo.unifiedName, DEVICE_NAME_BUF_LEN, "unifiedDefaultName"));
430     EXPECT_NO_FATAL_FAILURE(LnnSetDisplayName(displayName, nickName, &peerNodeInfo, &localNodeInfo, accountId));
431     const char *nickNameNew = "nickNameNew";
432     EXPECT_NO_FATAL_FAILURE(LnnSetDisplayName(displayName, nickNameNew, &peerNodeInfo, &localNodeInfo, accountId));
433     accountId = ACCOUNT_ID + 1;
434     (void)memset_s(peerNodeInfo.deviceInfo.unifiedName, DEVICE_NAME_BUF_LEN, 0, DEVICE_NAME_BUF_LEN);
435     EXPECT_NO_FATAL_FAILURE(LnnSetDisplayName(displayName, nickNameNew, &peerNodeInfo, &localNodeInfo, accountId));
436 }
437 } // namespace OHOS
438