1 /*
2 * Copyright (c) 2022-2023 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 "lnn_connection_mock.h"
20 #include "lnn_devicename_info.c"
21 #include "lnn_devicename_info.h"
22 #include "lnn_net_ledger_mock.h"
23 #include "lnn_service_mock.h"
24 #include "lnn_sync_info_mock.h"
25 #include "softbus_errcode.h"
26
27 namespace OHOS {
28 using namespace testing;
29 using namespace testing::ext;
30 NodeInfo *info = {0};
31 constexpr int64_t ACCOUNT_ID = 10;
32 constexpr char *DEVICE_NAME1 = nullptr;
33 constexpr char DEVICE_NAME2[] = "ABCDEFG";
34 constexpr uint32_t MSG_ERR_LEN0 = 0;
35 constexpr char NODE_UDID[] = "123456ABCDEF";
36 constexpr char NETWORKID[NETWORK_ID_BUF_LEN] = "123456ABD";
37
38 class LNNDeviceNameInfoTest : public testing::Test {
39 public:
40 static void SetUpTestCase();
41 static void TearDownTestCase();
42 void SetUp();
43 void TearDown();
44 };
45
SetUpTestCase()46 void LNNDeviceNameInfoTest::SetUpTestCase()
47 {
48 }
49
TearDownTestCase()50 void LNNDeviceNameInfoTest::TearDownTestCase()
51 {
52 }
53
SetUp()54 void LNNDeviceNameInfoTest::SetUp()
55 {
56 }
57
TearDown()58 void LNNDeviceNameInfoTest::TearDown()
59 {
60 }
61
62 /*
63 * @tc.name: LNN_UPDATE_DEVICE_NAME_TEST_001
64 * @tc.desc: no retry
65 * @tc.type: FUNC
66 * @tc.require:
67 */
68 HWTEST_F(LNNDeviceNameInfoTest, LNN_UPDATE_DEVICE_NAME_TEST_001, TestSize.Level1)
69 {
70 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
71 NiceMock<LnnServicetInterfaceMock> serviceMock;
72 NiceMock<LnnConnectInterfaceMock> connMock;
73 EXPECT_CALL(serviceMock, LnnGetSettingDeviceName).WillRepeatedly(
74 LnnServicetInterfaceMock::ActionOfLnnGetSettingDeviceName);
75 EXPECT_CALL(ledgerMock, LnnSetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
76 EXPECT_CALL(ledgerMock, LnnGetAllOnlineAndMetaNodeInfo).WillRepeatedly(Return(SOFTBUS_OK));
77 EXPECT_CALL(ledgerMock, LnnGetLocalNodeInfo).WillRepeatedly(Return(info));
78 EXPECT_CALL(ledgerMock, LnnGetDeviceName).WillRepeatedly(Return(DEVICE_NAME1));
79 EXPECT_CALL(ledgerMock, LnnGetDeviceName).WillRepeatedly(Return(DEVICE_NAME2));
80 EXPECT_CALL(serviceMock, LnnInitGetDeviceName).WillRepeatedly(
81 LnnServicetInterfaceMock::ActionOfLnnInitGetDeviceName);
82 EXPECT_CALL(serviceMock, RegisterNameMonitor).WillRepeatedly(Return());
83 EXPECT_CALL(connMock, DiscDeviceInfoChanged).WillRepeatedly(Return());
84 UpdateDeviceName(nullptr);
85 LnnDeviceNameHandler HandlerGetDeviceName = LnnServicetInterfaceMock::g_deviceNameHandler;
86 HandlerGetDeviceName(DEVICE_NAME_TYPE_DEV_NAME, nullptr);
87 }
88
89 /*
90 * @tc.name: LNN_UPDATE_DEVICE_NAME_TEST_002
91 * @tc.desc: looper is null
92 * @tc.type: FUNC
93 * @tc.require:
94 */
95 HWTEST_F(LNNDeviceNameInfoTest, LNN_UPDATE_DEVICE_NAME_TEST_002, TestSize.Level1)
96 {
97 NiceMock<LnnServicetInterfaceMock> serviceMock;
98 EXPECT_CALL(serviceMock, LnnInitGetDeviceName).WillRepeatedly(
99 LnnServicetInterfaceMock::ActionOfLnnInitGetDeviceName);
100 EXPECT_CALL(serviceMock, LnnGetSettingDeviceName(_, _)).WillRepeatedly(Return(SOFTBUS_ERR));
101 UpdateDeviceName(nullptr);
102 }
103
104 /*
105 * @tc.name: ON_RECEIVE_DEVICE_NAME_TEST_001
106 * @tc.desc: on receive device name test
107 * @tc.type: FUNC
108 * @tc.require:
109 */
110 HWTEST_F(LNNDeviceNameInfoTest, ON_RECEIVE_DEVICE_NAME_TEST_001, TestSize.Level1)
111 {
112 char msg[] = "msg";
113 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
114 NiceMock<LnnServicetInterfaceMock> serviceMock;
115 EXPECT_CALL(ledgerMock, LnnConvertDlId).WillOnce(Return(SOFTBUS_ERR)).WillRepeatedly(Return(SOFTBUS_OK));
116 EXPECT_CALL(ledgerMock, LnnSetDLDeviceInfoName).WillOnce(Return(false))
117 .WillRepeatedly(Return(true));
118 EXPECT_CALL(ledgerMock, LnnGetBasicInfoByUdid).WillOnce(Return(SOFTBUS_ERR))
119 .WillRepeatedly(Return(SOFTBUS_OK));
120 EXPECT_CALL(ledgerMock, LnnGetRemoteNodeInfoById).WillOnce(Return(SOFTBUS_ERR))
121 .WillRepeatedly(Return(SOFTBUS_OK));
122 EXPECT_CALL(serviceMock, LnnNotifyBasicInfoChanged).WillRepeatedly(Return());
123 EXPECT_CALL(serviceMock, UpdateProfile).WillRepeatedly(Return());
124 OnReceiveDeviceName(LNN_INFO_TYPE_COUNT, NETWORKID, reinterpret_cast<uint8_t *>(msg), strlen(msg) + 1);
125 OnReceiveDeviceName(LNN_INFO_TYPE_DEVICE_NAME, NETWORKID, reinterpret_cast<uint8_t *>(msg), MSG_ERR_LEN0);
126 OnReceiveDeviceName(LNN_INFO_TYPE_DEVICE_NAME, nullptr, reinterpret_cast<uint8_t *>(msg), strlen(msg) + 1);
127 OnReceiveDeviceName(LNN_INFO_TYPE_DEVICE_NAME, NETWORKID, nullptr, strlen(msg));
128 OnReceiveDeviceName(LNN_INFO_TYPE_DEVICE_NAME, NETWORKID, reinterpret_cast<uint8_t *>(msg), strlen(msg) + 1);
129 OnReceiveDeviceName(LNN_INFO_TYPE_DEVICE_NAME, NETWORKID, reinterpret_cast<uint8_t *>(msg), strlen(msg) + 1);
130 OnReceiveDeviceName(LNN_INFO_TYPE_DEVICE_NAME, NETWORKID, reinterpret_cast<uint8_t *>(msg), strlen(msg) + 1);
131 OnReceiveDeviceName(LNN_INFO_TYPE_DEVICE_NAME, NETWORKID, reinterpret_cast<uint8_t *>(msg), strlen(msg) + 1);
132 OnReceiveDeviceName(LNN_INFO_TYPE_DEVICE_NAME, NETWORKID, reinterpret_cast<uint8_t *>(msg), strlen(msg) + 1);
133 }
134
135 /*
136 * @tc.name: LNN_ACCOUNT_STATE_CHANGE_HANDLER_TEST_001
137 * @tc.desc: lnn account state change handler test
138 * @tc.type: FUNC
139 * @tc.require:
140 */
141 HWTEST_F(LNNDeviceNameInfoTest, LNN_ACCOUNT_STATE_CHANGE_HANDLER_TEST_001, TestSize.Level1)
142 {
143 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
144 EXPECT_CALL(ledgerMock, LnnGetLocalNodeInfo).WillRepeatedly(Return(nullptr));
145 LnnEventBasicInfo info1;
146 info1.event = LNN_EVENT_TYPE_MAX;
147 LnnAccountStateChangeHandler(nullptr);
148 LnnAccountStateChangeHandler(&info1);
149 info1.event = LNN_EVENT_ACCOUNT_CHANGED;
150 LnnAccountStateChangeHandler(&info1);
151 LnnAccountStateChangeHandler(&info1);
152 }
153
154 /*
155 * @tc.name: ON_RECEIVE_DEVICE_NICK_NAME_TEST_001
156 * @tc.desc: on receive device nick name test
157 * @tc.type: FUNC
158 * @tc.require:
159 */
160 HWTEST_F(LNNDeviceNameInfoTest, ON_RECEIVE_DEVICE_NICK_NAME_TEST_001, TestSize.Level1)
161 {
162 NodeInfo nodeInfo;
163 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
164 EXPECT_CALL(ledgerMock, LnnGetLocalNodeInfo).WillOnce(Return(nullptr)).WillRepeatedly(Return(&nodeInfo));
165 EXPECT_CALL(ledgerMock, LnnGetRemoteNodeInfoById)
166 .WillOnce(Return(SOFTBUS_ERR))
167 .WillRepeatedly(Return(SOFTBUS_OK));
168 char msg1[] = "{\"KEY_NICK_NAME\":\"nickName\"}";
169 char msg2[] = "{\"KEY_ACCOUNT\":10}";
170 char msg3[] = "{\"KEY_ACCOUNT\":10, \"KEY_NICK_NAME\":\"nickName\"}";
171 OnReceiveDeviceNickName(LNN_INFO_TYPE_NICK_NAME, NETWORKID, nullptr, strlen(msg1) + 1);
172 OnReceiveDeviceNickName(LNN_INFO_TYPE_COUNT, NETWORKID, reinterpret_cast<uint8_t *>(msg1), strlen(msg1) + 1);
173 OnReceiveDeviceNickName(LNN_INFO_TYPE_NICK_NAME, NETWORKID, reinterpret_cast<uint8_t *>(msg1), MSG_ERR_LEN0);
174 OnReceiveDeviceNickName(LNN_INFO_TYPE_NICK_NAME, NETWORKID, reinterpret_cast<uint8_t *>(msg1), strlen(msg1) + 1);
175 OnReceiveDeviceNickName(LNN_INFO_TYPE_NICK_NAME, NETWORKID, reinterpret_cast<uint8_t *>(msg2), strlen(msg2) + 1);
176 OnReceiveDeviceNickName(LNN_INFO_TYPE_NICK_NAME, NETWORKID, reinterpret_cast<uint8_t *>(msg3), strlen(msg3) + 1);
177 OnReceiveDeviceNickName(LNN_INFO_TYPE_NICK_NAME, NETWORKID, reinterpret_cast<uint8_t *>(msg3), strlen(msg3) + 1);
178 OnReceiveDeviceNickName(LNN_INFO_TYPE_NICK_NAME, NETWORKID, reinterpret_cast<uint8_t *>(msg3), strlen(msg3) + 1);
179 }
180
181 /*
182 * @tc.name: LNN_HANDLER_GET_DEVICE_NAME_TEST_001
183 * @tc.desc: lnn handler get device name test
184 * @tc.type: FUNC
185 * @tc.require:
186 */
187 HWTEST_F(LNNDeviceNameInfoTest, LNN_HANDLER_GET_DEVICE_NAME_TEST_001, TestSize.Level1)
188 {
189 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
190 NiceMock<LnnServicetInterfaceMock> serviceMock;
191 NiceMock<LnnConnectInterfaceMock> connMock;
192 EXPECT_CALL(connMock, DiscDeviceInfoChanged).WillRepeatedly(Return());
193 EXPECT_CALL(serviceMock, LnnGetSettingDeviceName)
194 .WillOnce(Return(SOFTBUS_ERR))
195 .WillRepeatedly(Return(SOFTBUS_OK));
196 EXPECT_CALL(serviceMock, LnnNotifyLocalNetworkIdChanged).WillRepeatedly(Return());
197 EXPECT_CALL(ledgerMock, LnnSetLocalStrInfo).WillOnce(Return(SOFTBUS_ERR))
198 .WillRepeatedly(Return(SOFTBUS_OK));
199 EXPECT_CALL(ledgerMock, LnnGetAllOnlineNodeInfo).WillRepeatedly(Return(SOFTBUS_ERR));
200 LnnHandlerGetDeviceName(DEVICE_NAME_TYPE_DEV_NAME, "deviceName");
201 LnnHandlerGetDeviceName(DEVICE_NAME_TYPE_DEV_NAME, "deviceName");
202 LnnHandlerGetDeviceName(DEVICE_NAME_TYPE_DEV_NAME, "deviceName");
203 LnnHandlerGetDeviceName(DEVICE_NAME_TYPE_DEV_NAME, "deviceName");
204 EXPECT_CALL(ledgerMock, LnnGetLocalNodeInfo).WillOnce(Return(nullptr));
205 LnnHandlerGetDeviceName(DEVICE_NAME_TYPE_NICK_NAME, "deviceName");
206 }
207
208 /*
209 * @tc.name: LNN_SYNC_DEVICE_NAME_TEST_001
210 * @tc.desc: lnn sync device name test
211 * @tc.type: FUNC
212 * @tc.require:
213 */
214 HWTEST_F(LNNDeviceNameInfoTest, LNN_SYNC_DEVICE_NAME_TEST_001, TestSize.Level1)
215 {
216 NodeInfo nodeInfo;
217 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
218 EXPECT_CALL(ledgerMock, LnnGetLocalNodeInfo).WillOnce(Return(nullptr))
219 .WillRepeatedly(Return(&nodeInfo));
220 EXPECT_CALL(ledgerMock, LnnGetDeviceName).WillOnce(Return(DEVICE_NAME1))
221 .WillRepeatedly(Return(DEVICE_NAME2));
222 NiceMock<LnnSyncInfoInterfaceMock> lnnSyncInfoMock;
223 EXPECT_CALL(lnnSyncInfoMock, LnnSendSyncInfoMsg).WillOnce(Return(SOFTBUS_ERR))
224 .WillRepeatedly(Return(SOFTBUS_OK));
225 int32_t ret = LnnSyncDeviceName(NETWORKID);
226 EXPECT_TRUE(ret == SOFTBUS_ERR);
227 ret = LnnSyncDeviceName(NETWORKID);
228 EXPECT_TRUE(ret == SOFTBUS_ERR);
229 ret = LnnSyncDeviceName(NETWORKID);
230 EXPECT_TRUE(ret == SOFTBUS_ERR);
231 ret = LnnSyncDeviceName(NETWORKID);
232 EXPECT_TRUE(ret == SOFTBUS_OK);
233 }
234
235 /*
236 * @tc.name: LNN_SYNC_DEVICE_NICK_NAME_TEST_001
237 * @tc.desc: lnn sync device nick name test
238 * @tc.type: FUNC
239 * @tc.require:
240 */
241 HWTEST_F(LNNDeviceNameInfoTest, LNN_SYNC_DEVICE_NICK_NAME_TEST_001, TestSize.Level1)
242 {
243 NodeInfo nodeInfo;
244 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
245 EXPECT_CALL(ledgerMock, LnnGetLocalNodeInfo).WillOnce(Return(nullptr))
246 .WillRepeatedly(Return(&nodeInfo));
247 NiceMock<LnnServicetInterfaceMock> serviceMock;
248 EXPECT_CALL(serviceMock, GetCurrentAccount).WillRepeatedly(Return(0));
249 NiceMock<LnnSyncInfoInterfaceMock> lnnSyncInfoMock;
250 EXPECT_CALL(lnnSyncInfoMock, LnnSendSyncInfoMsg).WillOnce(Return(SOFTBUS_ERR))
251 .WillRepeatedly(Return(SOFTBUS_OK));
252 int32_t ret = LnnSyncDeviceNickName(NETWORKID);
253 EXPECT_TRUE(ret == SOFTBUS_ERR);
254 ret = LnnSyncDeviceNickName(NETWORKID);
255 EXPECT_TRUE(ret == SOFTBUS_ERR);
256 ret = LnnSyncDeviceNickName(NETWORKID);
257 EXPECT_TRUE(ret == SOFTBUS_OK);
258 }
259
260 /*
261 * @tc.name: NICK_NAME_MSG_PROC_TEST_001
262 * @tc.desc: nick name msg proc test
263 * @tc.type: FUNC
264 * @tc.require:
265 */
266 HWTEST_F(LNNDeviceNameInfoTest, NICK_NAME_MSG_PROC_TEST_001, TestSize.Level1)
267 {
268 NodeInfo nodeInfo = { .accountId = ACCOUNT_ID + 1, };
269 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
270 NiceMock<LnnServicetInterfaceMock> serviceMock;
271 EXPECT_CALL(ledgerMock, LnnGetLocalNodeInfo).WillOnce(Return(nullptr))
272 .WillRepeatedly(Return(&nodeInfo));
273 EXPECT_CALL(ledgerMock, LnnSetDLDeviceNickName).WillRepeatedly(Return(SOFTBUS_OK));
274 EXPECT_CALL(ledgerMock, LnnGetBasicInfoByUdid).WillRepeatedly(Return(SOFTBUS_ERR));
275
276 NodeInfo peerNodeInfo1 = { .deviceInfo.nickName = "nickName", };
277 NodeInfo peerNodeInfo2 = {
278 .deviceInfo.nickName = "diffNickName",
279 .deviceInfo.unifiedName = "unifiedName",
280 .deviceInfo.unifiedDefaultName = "unifiedDefaultName",
281 .deviceInfo.deviceName = "deviceName",
282 };
283 NodeInfo peerNodeInfo3 = {
284 .deviceInfo.nickName = "diffNickName",
285 .deviceInfo.unifiedName = "",
286 .deviceInfo.unifiedDefaultName = "unifiedDefaultName",
287 .deviceInfo.deviceName = "deviceName",
288 };
289 EXPECT_CALL(ledgerMock, LnnGetRemoteNodeInfoById)
290 .WillOnce(Return(SOFTBUS_ERR))
291 .WillOnce(DoAll(SetArgPointee<2>(peerNodeInfo1), Return(SOFTBUS_OK)))
292 .WillOnce(DoAll(SetArgPointee<2>(peerNodeInfo2), Return(SOFTBUS_OK)))
293 .WillRepeatedly(DoAll(SetArgPointee<2>(peerNodeInfo3), Return(SOFTBUS_OK)));
294 const char *displayName = "";
295 EXPECT_CALL(serviceMock, LnnNotifyBasicInfoChanged).WillRepeatedly(Return());
296 EXPECT_CALL(serviceMock, LnnGetDeviceDisplayName)
297 .WillRepeatedly(DoAll(SetArgPointee<2>(*(const_cast<char *>(displayName))), Return(SOFTBUS_OK)));
298 NickNameMsgProc(NETWORKID, ACCOUNT_ID, "nickName");
299 NickNameMsgProc(NETWORKID, ACCOUNT_ID, "nickName");
300 NickNameMsgProc(NETWORKID, ACCOUNT_ID, "nickName");
301 NickNameMsgProc(NETWORKID, ACCOUNT_ID, "nickName");
302 NickNameMsgProc(NETWORKID, ACCOUNT_ID, "nickName");
303 NickNameMsgProc(NETWORKID, ACCOUNT_ID, "");
304 NickNameMsgProc(NETWORKID, ACCOUNT_ID, "nickName");
305 NickNameMsgProc(NETWORKID, ACCOUNT_ID, "nickName");
306 }
307
308 /*
309 * @tc.name: NOTIFY_DEVICE_DISPLAY_NAME_CHANGE_TEST_001
310 * @tc.desc: notify device display name change test
311 * @tc.type: FUNC
312 * @tc.require:
313 */
314 HWTEST_F(LNNDeviceNameInfoTest, NOTIFY_DEVICE_DISPLAY_NAME_CHANGE_TEST_001, TestSize.Level1)
315 {
316 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
317 NiceMock<LnnServicetInterfaceMock> serviceMock;
318 EXPECT_CALL(ledgerMock, LnnGetBasicInfoByUdid).WillOnce(Return(SOFTBUS_ERR))
319 .WillRepeatedly(Return(SOFTBUS_OK));
320 EXPECT_CALL(ledgerMock, LnnGetRemoteNodeInfoById).WillOnce(Return(SOFTBUS_ERR))
321 .WillRepeatedly(Return(SOFTBUS_OK));
322 EXPECT_CALL(serviceMock, LnnNotifyBasicInfoChanged).WillRepeatedly(Return());
323 EXPECT_CALL(serviceMock, UpdateProfile).WillRepeatedly(Return());
324 NotifyDeviceDisplayNameChange(NETWORKID, NODE_UDID);
325 NotifyDeviceDisplayNameChange(NETWORKID, NODE_UDID);
326 NotifyDeviceDisplayNameChange(NETWORKID, NODE_UDID);
327 }
328
329 /*
330 * @tc.name: IS_DEVICE_NEED_SYNC_NICK_NAME_TEST_001
331 * @tc.desc: Is Device Need Sync Nick Name test
332 * @tc.type: FUNC
333 * @tc.require:
334 */
335 HWTEST_F(LNNDeviceNameInfoTest, IS_DEVICE_NEED_SYNC_NICK_NAME_TEST_001, TestSize.Level1)
336 {
337 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
338 EXPECT_CALL(ledgerMock, LnnGetRemoteNodeInfoById)
339 .WillOnce(Return(SOFTBUS_OK))
340 .WillRepeatedly(Return(SOFTBUS_ERR));
341 NiceMock<LnnServicetInterfaceMock> serviceMock;
342 EXPECT_CALL(serviceMock, IsFeatureSupport).WillRepeatedly(Return(false));
343 bool ret = IsDeviceNeedSyncNickName(NETWORKID);
344 EXPECT_FALSE(ret);
345 ret = IsDeviceNeedSyncNickName(NETWORKID);
346 EXPECT_FALSE(ret);
347 }
348
349 /*
350 * @tc.name: NOTIFY_NICK_NAME_CHANGE_TEST_001
351 * @tc.desc: NotifyNickNameChange test
352 * @tc.type: FUNC
353 * @tc.require:
354 */
355 HWTEST_F(LNNDeviceNameInfoTest, NOTIFY_NICK_NAME_CHANGE_TEST_001, TestSize.Level1)
356 {
357 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
358 EXPECT_CALL(ledgerMock, LnnGetAllOnlineNodeInfo)
359 .WillOnce(Return(SOFTBUS_ERR))
360 .WillRepeatedly(LnnNetLedgertInterfaceMock::ActionOfLnnGetAllOnline);
361 EXPECT_CALL(ledgerMock, LnnGetRemoteNodeInfoById).WillOnce(Return(SOFTBUS_ERR));
362 NotifyNickNameChange();
363 NotifyNickNameChange();
364 EXPECT_CALL(ledgerMock, LnnGetRemoteNodeInfoById).WillRepeatedly(Return(SOFTBUS_OK));
365 NiceMock<LnnServicetInterfaceMock> serviceMock;
366 EXPECT_CALL(serviceMock, IsFeatureSupport).WillRepeatedly(Return(true));
367 EXPECT_CALL(ledgerMock, LnnGetLocalNodeInfo).WillOnce(Return(nullptr));
368 NotifyNickNameChange();
369 }
370
371 /*
372 * @tc.name: HANDLER_GET_DEVICE_NICK_NAME_TEST_001
373 * @tc.desc: HandlerGetDeviceNickName test
374 * @tc.type: FUNC
375 * @tc.require:
376 */
377 HWTEST_F(LNNDeviceNameInfoTest, HANDLER_GET_DEVICE_NICK_NAME_TEST_001, TestSize.Level1)
378 {
379 NodeInfo localNodeInfo1 = { .deviceInfo.unifiedName = "", };
380 NodeInfo localNodeInfo2 = { .deviceInfo.unifiedName = "nickName", };
381 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
382 NiceMock<LnnServicetInterfaceMock> serviceMock;
383 EXPECT_CALL(ledgerMock, LnnGetLocalNodeInfo).WillOnce(Return(nullptr));
384 HandlerGetDeviceNickName(nullptr);
385 EXPECT_CALL(ledgerMock, LnnGetLocalNodeInfo).WillOnce(Return(&localNodeInfo1));
386 EXPECT_CALL(serviceMock, LnnGetUnifiedDeviceName).WillOnce(Return(SOFTBUS_ERR));
387 HandlerGetDeviceNickName(nullptr);
388 EXPECT_CALL(ledgerMock, LnnGetLocalNodeInfo).WillOnce(Return(&localNodeInfo1));
389 EXPECT_CALL(serviceMock, LnnGetUnifiedDeviceName).WillRepeatedly(Return(SOFTBUS_OK));
390 EXPECT_CALL(serviceMock, LnnGetUnifiedDefaultDeviceName).WillOnce(Return(SOFTBUS_ERR));
391 HandlerGetDeviceNickName(nullptr);
392 EXPECT_CALL(ledgerMock, LnnGetLocalNodeInfo).WillOnce(Return(&localNodeInfo1));
393 const char *tmp = "";
394 EXPECT_CALL(serviceMock, LnnGetUnifiedDefaultDeviceName)
395 .WillOnce(DoAll(SetArgPointee<0>(*(const_cast<char *>(tmp))), Return(SOFTBUS_OK)));
396 EXPECT_CALL(serviceMock, LnnGetSettingNickName).WillOnce(Return(SOFTBUS_ERR));
397 HandlerGetDeviceNickName(nullptr);
398 EXPECT_CALL(ledgerMock, LnnGetLocalNodeInfo).WillOnce(Return(&localNodeInfo1));
399 EXPECT_CALL(serviceMock, LnnGetUnifiedDefaultDeviceName)
400 .WillOnce(DoAll(SetArgPointee<0>(*(const_cast<char *>(tmp))), Return(SOFTBUS_OK)));
401 EXPECT_CALL(serviceMock, LnnGetSettingNickName)
402 .WillOnce(DoAll(SetArgPointee<2>(*(const_cast<char *>(tmp))), Return(SOFTBUS_OK)));
403 EXPECT_CALL(ledgerMock, LnnGetAllOnlineNodeInfo).WillRepeatedly(Return(SOFTBUS_ERR));
404 HandlerGetDeviceNickName(nullptr);
405 const char *unifiedDefault = "unifiedDefault";
406 const char *nickName = "nickName";
407 EXPECT_CALL(ledgerMock, LnnGetLocalNodeInfo).WillRepeatedly(Return(&localNodeInfo2));
408 EXPECT_CALL(serviceMock, LnnSetLocalUnifiedName).WillOnce(Return(SOFTBUS_ERR));
409 EXPECT_CALL(serviceMock, LnnGetUnifiedDefaultDeviceName)
410 .WillOnce(DoAll(SetArgPointee<0>(*(const_cast<char *>(unifiedDefault))), Return(SOFTBUS_OK)));
411 EXPECT_CALL(ledgerMock, LnnSetLocalStrInfo)
412 .WillOnce(Return(SOFTBUS_ERR))
413 .WillOnce(Return(SOFTBUS_ERR));
414 EXPECT_CALL(serviceMock, LnnGetSettingNickName)
415 .WillOnce(DoAll(SetArgPointee<2>(*(const_cast<char *>(nickName))), Return(SOFTBUS_OK)));
416 HandlerGetDeviceNickName(nullptr);
417 EXPECT_CALL(serviceMock, LnnSetLocalUnifiedName).WillOnce(Return(SOFTBUS_OK));
418 EXPECT_CALL(serviceMock, LnnGetUnifiedDefaultDeviceName)
419 .WillOnce(DoAll(SetArgPointee<0>(*(const_cast<char *>(unifiedDefault))), Return(SOFTBUS_OK)));
420 EXPECT_CALL(ledgerMock, LnnSetLocalStrInfo)
421 .WillOnce(Return(SOFTBUS_OK))
422 .WillOnce(Return(SOFTBUS_OK));
423 EXPECT_CALL(serviceMock, LnnGetSettingNickName)
424 .WillOnce(DoAll(SetArgPointee<2>(*(const_cast<char *>(nickName))), Return(SOFTBUS_OK)));
425 HandlerGetDeviceNickName(nullptr);
426 }
427
428 /*
429 * @tc.name: UPDATA_LOCAL_FROM_SETTING_TEST_001
430 * @tc.desc: UpdataLocalFromSetting test
431 * @tc.type: FUNC
432 * @tc.require:
433 */
434 HWTEST_F(LNNDeviceNameInfoTest, UPDATA_LOCAL_FROM_SETTING_TEST_001, TestSize.Level1)
435 {
436 NiceMock<LnnServicetInterfaceMock> serviceMock;
437 const char *deviceName = "deviceName";
438 EXPECT_CALL(serviceMock, LnnGetSettingDeviceName)
439 .WillOnce(DoAll(SetArgPointee<0>(*(const_cast<char *>(deviceName))), Return(SOFTBUS_OK)));
440 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
441 EXPECT_CALL(ledgerMock, LnnSetLocalStrInfo)
442 .WillOnce(Return(SOFTBUS_ERR));
443 EXPECT_CALL(serviceMock, LnnGetUnifiedDeviceName).WillOnce(Return(SOFTBUS_ERR));
444 EXPECT_CALL(serviceMock, LnnGetUnifiedDefaultDeviceName).WillOnce(Return(SOFTBUS_ERR));
445 EXPECT_CALL(serviceMock, LnnGetSettingNickName).WillOnce(Return(SOFTBUS_ERR));
446 EXPECT_CALL(serviceMock, RegisterNameMonitor).WillRepeatedly(Return());
447 NiceMock<LnnConnectInterfaceMock> connMock;
448 EXPECT_CALL(connMock, DiscDeviceInfoChanged).WillRepeatedly(Return());
449 EXPECT_CALL(serviceMock, LnnNotifyLocalNetworkIdChanged).WillRepeatedly(Return());
450 UpdataLocalFromSetting(nullptr);
451
452 EXPECT_CALL(serviceMock, LnnGetSettingDeviceName)
453 .WillOnce(DoAll(SetArgPointee<0>(*(const_cast<char *>(deviceName))), Return(SOFTBUS_OK)));
454 EXPECT_CALL(ledgerMock, LnnSetLocalStrInfo)
455 .WillOnce(Return(SOFTBUS_OK));
456 const char *tmp = "";
457 EXPECT_CALL(serviceMock, LnnGetUnifiedDeviceName)
458 .WillOnce(DoAll(SetArgPointee<0>(*(const_cast<char *>(tmp))), Return(SOFTBUS_OK)));
459 EXPECT_CALL(serviceMock, LnnGetUnifiedDefaultDeviceName)
460 .WillOnce(DoAll(SetArgPointee<0>(*(const_cast<char *>(tmp))), Return(SOFTBUS_OK)));
461 EXPECT_CALL(serviceMock, LnnGetSettingNickName)
462 .WillOnce(DoAll(SetArgPointee<2>(*(const_cast<char *>(tmp))), Return(SOFTBUS_OK)));
463 UpdataLocalFromSetting(nullptr);
464 }
465
466 /*
467 * @tc.name: UPDATA_LOCAL_FROM_SETTING_TEST_002
468 * @tc.desc: UpdataLocalFromSetting test
469 * @tc.type: FUNC
470 * @tc.require:
471 */
472 HWTEST_F(LNNDeviceNameInfoTest, UPDATA_LOCAL_FROM_SETTING_TEST_002, TestSize.Level1)
473 {
474 NiceMock<LnnServicetInterfaceMock> serviceMock;
475 const char *deviceName = "deviceName";
476 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
477 const char *nickName = "nickName";
478 EXPECT_CALL(serviceMock, RegisterNameMonitor).WillRepeatedly(Return());
479 NiceMock<LnnConnectInterfaceMock> connMock;
480 EXPECT_CALL(connMock, DiscDeviceInfoChanged).WillRepeatedly(Return());
481 EXPECT_CALL(serviceMock, LnnNotifyLocalNetworkIdChanged).WillRepeatedly(Return());
482
483 EXPECT_CALL(serviceMock, LnnGetSettingDeviceName)
484 .WillRepeatedly(DoAll(SetArgPointee<0>(*(const_cast<char *>(deviceName))), Return(SOFTBUS_OK)));
485 EXPECT_CALL(ledgerMock, LnnSetLocalStrInfo)
486 .WillOnce(Return(SOFTBUS_OK))
487 .WillRepeatedly(Return(SOFTBUS_ERR));
488 EXPECT_CALL(serviceMock, LnnGetUnifiedDeviceName)
489 .WillRepeatedly(DoAll(SetArgPointee<0>(*(const_cast<char *>(deviceName))), Return(SOFTBUS_OK)));
490 EXPECT_CALL(serviceMock, LnnGetUnifiedDefaultDeviceName)
491 .WillRepeatedly(DoAll(SetArgPointee<0>(*(const_cast<char *>(deviceName))), Return(SOFTBUS_OK)));
492 EXPECT_CALL(serviceMock, LnnGetSettingNickName)
493 .WillRepeatedly(DoAll(SetArgPointee<2>(*(const_cast<char *>(nickName))), Return(SOFTBUS_OK)));
494 UpdataLocalFromSetting(nullptr);
495 }
496
497 /*
498 * @tc.name: UPDATA_LOCAL_FROM_SETTING_TEST_003
499 * @tc.desc: UpdataLocalFromSetting test
500 * @tc.type: FUNC
501 * @tc.require:
502 */
503 HWTEST_F(LNNDeviceNameInfoTest, UPDATA_LOCAL_FROM_SETTING_TEST_003, TestSize.Level1)
504 {
505 NiceMock<LnnServicetInterfaceMock> serviceMock;
506 const char *deviceName = "deviceName";
507 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
508 const char *nickName = "nickName";
509
510 EXPECT_CALL(serviceMock, LnnGetSettingDeviceName)
511 .WillOnce(DoAll(SetArgPointee<0>(*(const_cast<char *>(deviceName))), Return(SOFTBUS_OK)))
512 .WillRepeatedly(Return(SOFTBUS_ERR));
513 EXPECT_CALL(ledgerMock, LnnSetLocalStrInfo)
514 .WillRepeatedly(Return(SOFTBUS_OK));
515 EXPECT_CALL(serviceMock, LnnGetUnifiedDeviceName)
516 .WillRepeatedly(DoAll(SetArgPointee<0>(*(const_cast<char *>(deviceName))), Return(SOFTBUS_OK)));
517 EXPECT_CALL(serviceMock, LnnGetUnifiedDefaultDeviceName)
518 .WillRepeatedly(DoAll(SetArgPointee<0>(*(const_cast<char *>(deviceName))), Return(SOFTBUS_OK)));
519 EXPECT_CALL(serviceMock, LnnGetSettingNickName)
520 .WillRepeatedly(DoAll(SetArgPointee<2>(*(const_cast<char *>(nickName))), Return(SOFTBUS_OK)));
521 EXPECT_CALL(serviceMock, RegisterNameMonitor).WillRepeatedly(Return());
522 NiceMock<LnnConnectInterfaceMock> connMock;
523 EXPECT_CALL(connMock, DiscDeviceInfoChanged).WillRepeatedly(Return());
524 EXPECT_CALL(serviceMock, LnnNotifyLocalNetworkIdChanged).WillRepeatedly(Return());
525 UpdataLocalFromSetting(nullptr);
526 UpdataLocalFromSetting(nullptr);
527 }
528
529 /*
530 * @tc.name: LNN_INIT_DEVICE_NAME_TEST_001
531 * @tc.desc: UpdataLocalFromSetting test
532 * @tc.type: FUNC
533 * @tc.require:
534 */
535 HWTEST_F(LNNDeviceNameInfoTest, LNN_INIT_DEVICE_NAME_TEST_001, TestSize.Level1)
536 {
537 NiceMock<LnnSyncInfoInterfaceMock> lnnSyncInfoMock;
538 EXPECT_CALL(lnnSyncInfoMock, LnnRegSyncInfoHandler).WillOnce(Return(SOFTBUS_ERR))
539 .WillRepeatedly(Return(SOFTBUS_OK));
540 int32_t ret = LnnInitDevicename();
541 EXPECT_EQ(ret, SOFTBUS_ERR);
542 NiceMock<LnnServicetInterfaceMock> serviceMock;
543 EXPECT_CALL(serviceMock, LnnRegisterEventHandler).WillOnce(Return(SOFTBUS_ERR))
544 .WillRepeatedly(Return(SOFTBUS_OK));
545 ret = LnnInitDevicename();
546 EXPECT_EQ(ret, SOFTBUS_ERR);
547 ret = LnnInitDevicename();
548 EXPECT_EQ(ret, SOFTBUS_OK);
549 }
550 } // namespace OHOS
551