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 "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))
70 .WillRepeatedly(Return(SOFTBUS_OK));
71 EXPECT_CALL(ledgerMock, LnnSetDLDeviceInfoName).WillOnce(Return(false))
72 .WillRepeatedly(Return(true));
73 EXPECT_CALL(ledgerMock, LnnGetBasicInfoByUdid).WillOnce(Return(SOFTBUS_INVALID_PARAM))
74 .WillRepeatedly(Return(SOFTBUS_OK));
75 EXPECT_CALL(ledgerMock, LnnGetRemoteNodeInfoById).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))
101 .WillRepeatedly(Return(&nodeInfo));
102 EXPECT_CALL(ledgerMock, LnnGetRemoteNodeInfoById)
103 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
104 .WillRepeatedly(Return(SOFTBUS_OK));
105 char msg1[] = "{\"KEY_NICK_NAME\":\"nickName\"}";
106 char msg2[] = "{\"KEY_ACCOUNT\":10}";
107 char msg3[] = "{\"KEY_ACCOUNT\":10, \"KEY_NICK_NAME\":\"nickName\"}";
108 OnReceiveDeviceNickName(LNN_INFO_TYPE_NICK_NAME, NETWORKID, nullptr, strlen(msg1) + 1);
109 OnReceiveDeviceNickName(LNN_INFO_TYPE_COUNT, NETWORKID, reinterpret_cast<uint8_t *>(msg1), strlen(msg1) + 1);
110 OnReceiveDeviceNickName(LNN_INFO_TYPE_NICK_NAME, NETWORKID, reinterpret_cast<uint8_t *>(msg1), MSG_ERR_LEN0);
111 OnReceiveDeviceNickName(LNN_INFO_TYPE_NICK_NAME, NETWORKID, reinterpret_cast<uint8_t *>(msg1), strlen(msg1) + 1);
112 OnReceiveDeviceNickName(LNN_INFO_TYPE_NICK_NAME, NETWORKID, reinterpret_cast<uint8_t *>(msg2), strlen(msg2) + 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 OnReceiveDeviceNickName(LNN_INFO_TYPE_NICK_NAME, NETWORKID, reinterpret_cast<uint8_t *>(msg3), strlen(msg3) + 1);
116 }
117
118 /*
119 * @tc.name: LNN_SYNC_DEVICE_NAME_TEST_001
120 * @tc.desc: lnn sync device name test
121 * @tc.type: FUNC
122 * @tc.require:
123 */
124 HWTEST_F(LNNDeviceNameInfoTest, LNN_SYNC_DEVICE_NAME_TEST_001, TestSize.Level1)
125 {
126 NodeInfo nodeInfo;
127 SendSyncInfoParam *data = (SendSyncInfoParam *)SoftBusMalloc(sizeof(SendSyncInfoParam));
128 EXPECT_TRUE(data != nullptr);
129 memset_s(data, sizeof(SendSyncInfoParam), 0, sizeof(SendSyncInfoParam));
130 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
131 EXPECT_CALL(ledgerMock, LnnGetLocalNodeInfo).WillOnce(Return(nullptr))
132 .WillRepeatedly(Return(&nodeInfo));
133 EXPECT_CALL(ledgerMock, LnnGetDeviceName).WillOnce(Return(DEVICE_NAME1))
134 .WillRepeatedly(Return(DEVICE_NAME2));
135 NiceMock<LnnSyncInfoInterfaceMock> lnnSyncInfoMock;
136 EXPECT_CALL(lnnSyncInfoMock, CreateSyncInfoParam).WillOnce(Return(nullptr))
137 .WillRepeatedly(Return(data));
138 NiceMock<LnnServicetInterfaceMock> ServiceMock;
139 EXPECT_CALL(ServiceMock, LnnAsyncCallbackHelper)
140 .WillRepeatedly(Return(SOFTBUS_OK));
141 int32_t ret = LnnSyncDeviceName(NETWORKID);
142 EXPECT_TRUE(ret == SOFTBUS_NETWORK_GET_LOCAL_NODE_INFO_ERR);
143 ret = LnnSyncDeviceName(NETWORKID);
144 EXPECT_TRUE(ret == SOFTBUS_NETWORK_GET_DEVICE_INFO_ERR);
145 ret = LnnSyncDeviceName(NETWORKID);
146 EXPECT_TRUE(ret == SOFTBUS_NETWORK_SEND_SYNC_INFO_FAILED);
147 ret = LnnSyncDeviceName(NETWORKID);
148 EXPECT_TRUE(ret == SOFTBUS_OK);
149 SoftBusFree(data->msg);
150 SoftBusFree(data);
151 }
152
153 /*
154 * @tc.name: NICK_NAME_MSG_PROC_TEST_001
155 * @tc.desc: nick name msg proc test
156 * @tc.type: FUNC
157 * @tc.require:
158 */
159 HWTEST_F(LNNDeviceNameInfoTest, NICK_NAME_MSG_PROC_TEST_001, TestSize.Level1)
160 {
161 NodeInfo nodeInfo = {
162 .accountId = ACCOUNT_ID + 1,
163 };
164 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
165 NiceMock<LnnServicetInterfaceMock> serviceMock;
166 EXPECT_CALL(ledgerMock, LnnGetLocalNodeInfo).WillOnce(Return(nullptr))
167 .WillRepeatedly(Return(&nodeInfo));
168 EXPECT_CALL(ledgerMock, LnnSetDLDeviceNickName).WillRepeatedly(Return(SOFTBUS_OK));
169 EXPECT_CALL(ledgerMock, LnnGetBasicInfoByUdid).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
170
171 NodeInfo peerNodeInfo1 = {
172 .deviceInfo.nickName = "nickName",
173 };
174 NodeInfo peerNodeInfo2 = {
175 .deviceInfo.nickName = "diffNickName",
176 .deviceInfo.unifiedName = "unifiedName",
177 .deviceInfo.unifiedDefaultName = "unifiedDefaultName",
178 .deviceInfo.deviceName = "deviceName",
179 };
180 NodeInfo peerNodeInfo3 = {
181 .deviceInfo.nickName = "diffNickName",
182 .deviceInfo.unifiedName = "",
183 .deviceInfo.unifiedDefaultName = "unifiedDefaultName",
184 .deviceInfo.deviceName = "deviceName",
185 };
186 EXPECT_CALL(ledgerMock, LnnGetRemoteNodeInfoById)
187 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
188 .WillOnce(DoAll(SetArgPointee<2>(peerNodeInfo1), Return(SOFTBUS_OK)))
189 .WillOnce(DoAll(SetArgPointee<2>(peerNodeInfo2), Return(SOFTBUS_OK)))
190 .WillRepeatedly(DoAll(SetArgPointee<2>(peerNodeInfo3), Return(SOFTBUS_OK)));
191 const char *displayName = "";
192 EXPECT_CALL(serviceMock, LnnNotifyBasicInfoChanged).WillRepeatedly(Return());
193 EXPECT_CALL(serviceMock, LnnGetDeviceDisplayName)
194 .WillRepeatedly(DoAll(SetArgPointee<2>(*(const_cast<char *>(displayName))), Return(SOFTBUS_OK)));
195 NickNameMsgProc(NETWORKID, ACCOUNT_ID, "nickName");
196 NickNameMsgProc(NETWORKID, ACCOUNT_ID, "nickName");
197 NickNameMsgProc(NETWORKID, ACCOUNT_ID, "nickName");
198 NickNameMsgProc(NETWORKID, ACCOUNT_ID, "nickName");
199 NickNameMsgProc(NETWORKID, ACCOUNT_ID, "nickName");
200 NickNameMsgProc(NETWORKID, ACCOUNT_ID, "");
201 NickNameMsgProc(NETWORKID, ACCOUNT_ID, "nickName");
202 NickNameMsgProc(NETWORKID, ACCOUNT_ID, "nickName");
203 }
204
205 /*
206 * @tc.name: NOTIFY_DEVICE_DISPLAY_NAME_CHANGE_TEST_001
207 * @tc.desc: notify device display name change test
208 * @tc.type: FUNC
209 * @tc.require:
210 */
211 HWTEST_F(LNNDeviceNameInfoTest, NOTIFY_DEVICE_DISPLAY_NAME_CHANGE_TEST_001, TestSize.Level1)
212 {
213 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
214 NiceMock<LnnServicetInterfaceMock> serviceMock;
215 EXPECT_CALL(ledgerMock, LnnGetBasicInfoByUdid).WillOnce(Return(SOFTBUS_INVALID_PARAM))
216 .WillRepeatedly(Return(SOFTBUS_OK));
217 EXPECT_CALL(ledgerMock, LnnGetRemoteNodeInfoById).WillOnce(Return(SOFTBUS_INVALID_PARAM))
218 .WillRepeatedly(Return(SOFTBUS_OK));
219 EXPECT_CALL(serviceMock, LnnNotifyBasicInfoChanged).WillRepeatedly(Return());
220 EXPECT_CALL(serviceMock, UpdateProfile).WillRepeatedly(Return());
221 NotifyDeviceDisplayNameChange(NETWORKID, NODE_UDID);
222 NotifyDeviceDisplayNameChange(NETWORKID, NODE_UDID);
223 NotifyDeviceDisplayNameChange(NETWORKID, NODE_UDID);
224 }
225
226 /*
227 * @tc.name: LNN_INIT_DEVICE_NAME_TEST_001
228 * @tc.desc: LnnInitDevicename test
229 * @tc.type: FUNC
230 * @tc.require:
231 */
232 HWTEST_F(LNNDeviceNameInfoTest, LNN_INIT_DEVICE_NAME_TEST_001, TestSize.Level1)
233 {
234 NiceMock<LnnSyncInfoInterfaceMock> lnnSyncInfoMock;
235 EXPECT_CALL(lnnSyncInfoMock, LnnRegSyncInfoHandler).WillRepeatedly(Return(SOFTBUS_LOCK_ERR));
236 int32_t ret = LnnInitDevicename();
237 EXPECT_EQ(ret, SOFTBUS_LOCK_ERR);
238 }
239
240
241 /*
242 * @tc.name: LNN_SET_LOCAL_DEVICE_NAME_TEST_001
243 * @tc.desc: LnnSetLocalDeviceName test
244 * @tc.type: FUNC
245 * @tc.require:
246 */
247 HWTEST_F(LNNDeviceNameInfoTest, LNN_SET_LOCAL_DEVICE_NAME_TEST_001, TestSize.Level1)
248 {
249 NiceMock<LnnServicetInterfaceMock> serviceMock;
250 EXPECT_CALL(serviceMock, LnnNotifyLocalNetworkIdChanged).WillRepeatedly(Return());
251 EXPECT_CALL(serviceMock, LnnNotifyDeviceInfoChanged).WillRepeatedly(Return());
252 int32_t ret = LnnSetLocalDeviceName(DEVICE_NAME1);
253 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
254 ret = LnnSetLocalDeviceName(DEVICE_NAME3);
255 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
256 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
257 EXPECT_CALL(ledgerMock, LnnGetLocalStrInfo).WillOnce(Return(SOFTBUS_INVALID_PARAM));
258 ret = LnnSetLocalDeviceName(DEVICE_NAME2);
259 EXPECT_EQ(ret, SOFTBUS_NETWORK_GET_NODE_INFO_ERR);
260 const char* info = "ABCDEFG";
261 EXPECT_CALL(ledgerMock, LnnGetLocalStrInfo).WillOnce(DoAll(SetArgPointee<1>(*info), Return(SOFTBUS_OK)));
262 ret = LnnSetLocalDeviceName(DEVICE_NAME2);
263 EXPECT_EQ(ret, SOFTBUS_OK);
264 const char* info1 = "ABCDEFGHIGKL";
265 EXPECT_CALL(ledgerMock, LnnGetLocalStrInfo).WillRepeatedly(DoAll(SetArgPointee<1>(*info1), Return(SOFTBUS_OK)));
266 EXPECT_CALL(ledgerMock, LnnSetLocalStrInfo).WillOnce(Return(SOFTBUS_INVALID_PARAM))
267 .WillRepeatedly(Return(SOFTBUS_OK));
268 ret = LnnSetLocalDeviceName(DEVICE_NAME2);
269 EXPECT_EQ(ret, SOFTBUS_NETWORK_SET_NODE_INFO_ERR);
270 EXPECT_CALL(ledgerMock, LnnGetAllOnlineNodeInfo).WillOnce(Return(SOFTBUS_INVALID_PARAM))
271 .WillRepeatedly(DoAll(SetArgPointee<1>(1), Return(SOFTBUS_OK)));
272 ret = LnnSetLocalDeviceName(DEVICE_NAME2);
273 EXPECT_EQ(ret, SOFTBUS_NETWORK_GET_ALL_NODE_INFO_ERR);
274 EXPECT_CALL(ledgerMock, LnnIsLSANode).WillRepeatedly(Return(true));
275 ret = LnnSetLocalDeviceName(DEVICE_NAME2);
276 EXPECT_EQ(ret, SOFTBUS_OK);
277 }
278
279 /*
280 * @tc.name: LNN_ASYNC_DEVICE_NAME_DALEY_TEST_001
281 * @tc.desc: lnn Async device name test
282 * @tc.type: FUNC
283 * @tc.require:
284 */
285 HWTEST_F(LNNDeviceNameInfoTest, LNN_ASYNC_DEVICE_NAME_DALEY_TEST_001, TestSize.Level1)
286 {
287 NodeInfo nodeInfo;
288 SendSyncInfoParam *data = (SendSyncInfoParam *)SoftBusMalloc(sizeof(SendSyncInfoParam));
289 EXPECT_TRUE(data != nullptr);
290 memset_s(data, sizeof(SendSyncInfoParam), 0, sizeof(SendSyncInfoParam));
291
292 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
293 EXPECT_CALL(ledgerMock, LnnGetLocalNodeInfo).WillOnce(Return(nullptr)).WillRepeatedly(Return(&nodeInfo));
294 EXPECT_CALL(ledgerMock, LnnGetDeviceName).WillOnce(Return(DEVICE_NAME1)).WillRepeatedly(Return(DEVICE_NAME2));
295 NiceMock<LnnSyncInfoInterfaceMock> lnnSyncInfoMock;
296 EXPECT_CALL(lnnSyncInfoMock, CreateSyncInfoParam).WillOnce(Return(nullptr)).WillRepeatedly(Return(data));
297 NiceMock<LnnServicetInterfaceMock> ServiceMock;
298 EXPECT_CALL(ServiceMock, LnnAsyncCallbackDelayHelper).WillRepeatedly(Return(SOFTBUS_OK));
299
300 int32_t ret = LnnAsyncDeviceNameDelay(NETWORKID);
301 EXPECT_TRUE(ret == SOFTBUS_NETWORK_GET_LOCAL_NODE_INFO_ERR);
302
303 ret = LnnAsyncDeviceNameDelay(NETWORKID);
304 EXPECT_TRUE(ret == SOFTBUS_NETWORK_GET_DEVICE_INFO_ERR);
305
306 ret = LnnAsyncDeviceNameDelay(NETWORKID);
307 EXPECT_TRUE(ret == SOFTBUS_NETWORK_CREATE_SYNC_INFO_PARAM_FAILED);
308
309 ret = LnnAsyncDeviceNameDelay(NETWORKID);
310 EXPECT_TRUE(ret == SOFTBUS_OK);
311 SoftBusFree(data);
312 }
313 } // namespace OHOS
314