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 <cstddef>
17 #include <cstdlib>
18 #include <cstring>
19 #include <gtest/gtest.h>
20 #include <securec.h>
21
22 #include "bus_center_manager.h"
23 #include "legacy/softbus_hidumper_buscenter.h"
24 #include "lnn_connection_addr_utils.h"
25 #include "lnn_distributed_net_ledger.c"
26 #include "lnn_distributed_net_ledger.h"
27 #include "lnn_distributed_net_ledger_manager.c"
28 #include "lnn_log.h"
29 #include "lnn_map.h"
30 #include "lnn_node_info.h"
31 #include "softbus_adapter_mem.h"
32 #include "softbus_adapter_thread.h"
33 #include "softbus_bus_center.h"
34 #include "softbus_error_code.h"
35 #include "softbus_utils.h"
36 #include "dsoftbus_enhance_interface.h"
37 #include "g_enhance_lnn_func.h"
38 #include "lnn_disctributed_net_ledger_mock.h"
39
40 namespace OHOS {
41 using namespace testing;
42 using namespace testing::ext;
43 constexpr char NODE1_DEVICE_NAME[] = "node1_test";
44 constexpr char NODE1_UDID[] = "123456ABCDEF";
45 constexpr char NODE1_NETWORK_ID[] = "235689BNHFCF";
46 constexpr char NODE1_UUID[] = "235689BNHFCC";
47 constexpr char NODE1_BT_MAC[] = "56789TTU";
48 constexpr char NODE2_DEVICE_NAME[] = "node2_test";
49 constexpr char NODE2_UDID[] = "123456ABCDEG";
50 constexpr char NODE2_NETWORK_ID[] = "235689BNHFCG";
51 constexpr char NODE2_UUID[] = "235689BNHFCD";
52 constexpr char NODE2_BT_MAC[] = "56789TYU";
53 constexpr char P2P_MAC[] = "11:22:33:44:55";
54 constexpr char GO_MAC[] = "22:33:44:55:66";
55 constexpr int32_t P2P_ROLE = 1;
56 constexpr uint32_t DISCOVERY_TYPE = 62;
57 constexpr int32_t AUTH_ID = 10;
58 constexpr uint64_t TIME_STAMP = 5000;
59 constexpr uint64_t CAPABILITY = 62;
60 constexpr uint64_t NEW_TIME_STAMP = 6000;
61 constexpr int64_t AUTH_SEQ = 1;
62 constexpr char NODE_ADDRESS[] = "address";
63 constexpr char RECV_UDID_HASH[] = "87654321";
64 constexpr char NODE3_UDID[] = "3456789udidtest";
65 constexpr char ACCOUNT_HASH[] = "5FFFFEC";
66 constexpr char SOFTBUS_VERSION[] = "00";
67 using namespace testing;
68 class LNNDisctributedLedgerTest : public testing::Test {
69 public:
70 static void SetUpTestCase();
71 static void TearDownTestCase();
72 void SetUp();
73 void TearDown();
74 };
75
TestFunc(NodeBasicInfo * info)76 void TestFunc(NodeBasicInfo *info)
77 {
78 (void)info;
79 return;
80 }
81
SetUpTestCase()82 void LNNDisctributedLedgerTest::SetUpTestCase() { }
83
TearDownTestCase()84 void LNNDisctributedLedgerTest::TearDownTestCase() { }
85
SetUp()86 void LNNDisctributedLedgerTest::SetUp()
87 {
88 LNN_LOGI(LNN_TEST, "LocalLedgerTest start");
89 LnnEnhanceFuncList *pfnLnnEnhanceFuncList = LnnEnhanceFuncListGet();
90 pfnLnnEnhanceFuncList->lnnRetrieveDeviceInfo = LnnRetrieveDeviceInfo;
91 int32_t ret = LnnInitDistributedLedger();
92 EXPECT_EQ(ret, SOFTBUS_OK);
93 NodeInfo info;
94 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
95 info.discoveryType = DISCOVERY_TYPE;
96 (void)strncpy_s(info.uuid, UUID_BUF_LEN, NODE1_UUID, strlen(NODE1_UUID));
97 (void)strncpy_s(info.deviceInfo.deviceUdid, UDID_BUF_LEN, NODE1_UDID, strlen(NODE1_UDID));
98 (void)strncpy_s(info.networkId, NETWORK_ID_BUF_LEN, NODE1_NETWORK_ID, strlen(NODE1_NETWORK_ID));
99 (void)strncpy_s(info.connectInfo.macAddr, MAC_LEN, NODE1_BT_MAC, strlen(NODE1_BT_MAC));
100 info.authSeq[0] = AUTH_SEQ;
101 info.heartbeatTimestamp = TIME_STAMP;
102 info.deviceInfo.osType = HO_OS_TYPE;
103
104 NiceMock<LnnDisctributedNetLedgerInterfaceMock> mock;
105 EXPECT_CALL(mock, LnnRetrieveDeviceInfo).WillRepeatedly(Return(SOFTBUS_OK));
106 EXPECT_EQ(REPORT_ONLINE, LnnAddOnlineNode(&info));
107 }
108
TearDown()109 void LNNDisctributedLedgerTest::TearDown()
110 {
111 LNN_LOGI(LNN_TEST, "LocalLedgerTest end");
112 LnnDeinitDistributedLedger();
113 }
114
115 /*
116 * @tc.name: LNN_ADD_ONLINE_NODE_Test_001
117 * @tc.desc: lnn add online node test
118 * @tc.type: FUNC
119 * @tc.require:
120 */
121 HWTEST_F(LNNDisctributedLedgerTest, LNN_ADD_ONLINE_NODE_Test_001, TestSize.Level1)
122 {
123 LnnEnhanceFuncList *pfnLnnEnhanceFuncList = LnnEnhanceFuncListGet();
124 pfnLnnEnhanceFuncList->lnnRetrieveDeviceInfo = LnnRetrieveDeviceInfo;
125
126 NiceMock<LnnDisctributedNetLedgerInterfaceMock> mock;
127 EXPECT_CALL(mock, LnnRetrieveDeviceInfo).WillRepeatedly(Return(SOFTBUS_OK));
128 NodeInfo info;
129 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
130 info.discoveryType = DISCOVERY_TYPE;
131 (void)strncpy_s(info.uuid, UUID_BUF_LEN, NODE1_UUID, strlen(NODE1_UUID));
132 (void)strncpy_s(info.deviceInfo.deviceUdid, UDID_BUF_LEN, NODE1_UDID, strlen(NODE1_UDID));
133 (void)strncpy_s(info.networkId, NETWORK_ID_BUF_LEN, NODE1_NETWORK_ID, strlen(NODE1_NETWORK_ID));
134 (void)strncpy_s(info.connectInfo.macAddr, MAC_LEN, NODE1_BT_MAC, strlen(NODE1_BT_MAC));
135 EXPECT_EQ(REPORT_NONE, LnnAddOnlineNode(&info));
136 }
137
138 /*
139 * @tc.name: LNN_GET_REMOTE_STRINFO_Test_001
140 * @tc.desc: lnn get remote strInfo test
141 * @tc.type: FUNC
142 * @tc.require:
143 */
144 HWTEST_F(LNNDisctributedLedgerTest, LNN_GET_REMOTE_STRINFO_Test_001, TestSize.Level1)
145 {
146 static InfoKey keyStringTable[] = { STRING_KEY_HICE_VERSION, STRING_KEY_DEV_UDID, STRING_KEY_UUID,
147 STRING_KEY_DEV_TYPE, STRING_KEY_DEV_NAME, STRING_KEY_BT_MAC, STRING_KEY_MASTER_NODE_UDID,
148 STRING_KEY_P2P_MAC, STRING_KEY_P2P_GO_MAC, STRING_KEY_NODE_ADDR, STRING_KEY_OFFLINE_CODE,
149 STRING_KEY_WIFIDIRECT_ADDR };
150 char buf[UDID_BUF_LEN] = { 0 };
151 int32_t ret = LnnGetRemoteStrInfo(nullptr, STRING_KEY_HICE_VERSION, buf, UDID_BUF_LEN);
152 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
153 ret = LnnGetRemoteStrInfo(NODE1_NETWORK_ID, STRING_KEY_HICE_VERSION, nullptr, UDID_BUF_LEN);
154 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
155 ret = LnnGetRemoteStrInfo(NODE1_NETWORK_ID, NUM_KEY_BEGIN, buf, UDID_BUF_LEN);
156 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
157 uint32_t i;
158 for (i = 0; i < sizeof(keyStringTable) / sizeof(InfoKey); i++) {
159 (void)memset_s(buf, UDID_BUF_LEN, 0, UDID_BUF_LEN);
160 ret = LnnGetRemoteStrInfo(NODE1_NETWORK_ID, keyStringTable[i], buf, UDID_BUF_LEN);
161 EXPECT_EQ(ret, SOFTBUS_OK);
162 }
163 for (i = 0; i < sizeof(keyStringTable) / sizeof(InfoKey); i++) {
164 ret = LnnGetRemoteStrInfo(NODE2_NETWORK_ID, keyStringTable[i], buf, UDID_BUF_LEN);
165 EXPECT_EQ(ret, SOFTBUS_NETWORK_GET_NODE_INFO_ERR);
166 }
167 }
168
169 /*
170 * @tc.name: LNN_GET_REMOTE_STRINFO_BY_IFNAME_Test_001
171 * @tc.desc: lnn get remote strInfo by ifname test
172 * @tc.type: FUNC
173 * @tc.require:
174 */
175 HWTEST_F(LNNDisctributedLedgerTest, LNN_GET_REMOTE_STRINFO_BY_IFNAME_Test_001, TestSize.Level1)
176 {
177 static InfoKey keyStringTable[] = { STRING_KEY_IP };
178 char buf[UDID_BUF_LEN] = { 0 };
179 int32_t ret = LnnGetRemoteStrInfoByIfnameIdx(nullptr, STRING_KEY_HICE_VERSION, buf, UDID_BUF_LEN, WLAN_IF);
180 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
181 ret = LnnGetRemoteStrInfoByIfnameIdx(NODE1_NETWORK_ID, STRING_KEY_HICE_VERSION, nullptr, UDID_BUF_LEN, WLAN_IF);
182 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
183 ret = LnnGetRemoteStrInfoByIfnameIdx(NODE1_NETWORK_ID, NUM_KEY_BEGIN, buf, UDID_BUF_LEN, WLAN_IF);
184 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
185 uint32_t i;
186 for (i = 0; i < sizeof(keyStringTable) / sizeof(InfoKey); i++) {
187 (void)memset_s(buf, UDID_BUF_LEN, 0, UDID_BUF_LEN);
188 ret = LnnGetRemoteStrInfoByIfnameIdx(NODE1_NETWORK_ID, keyStringTable[i], buf, UDID_BUF_LEN, WLAN_IF);
189 EXPECT_EQ(ret, SOFTBUS_OK);
190 }
191 for (i = 0; i < sizeof(keyStringTable) / sizeof(InfoKey); i++) {
192 ret = LnnGetRemoteStrInfoByIfnameIdx(NODE2_NETWORK_ID, keyStringTable[i], buf, UDID_BUF_LEN, WLAN_IF);
193 EXPECT_EQ(ret, SOFTBUS_NETWORK_GET_NODE_INFO_ERR);
194 }
195 }
196
197 /*
198 * @tc.name: LNN_GET_REMOTE_NUMNFO_Test_002
199 * @tc.desc: lnn get remote num info test
200 * @tc.type: FUNC
201 * @tc.require:
202 */
203 HWTEST_F(LNNDisctributedLedgerTest, LNN_GET_REMOTE_NUMNFO_Test_002, TestSize.Level1)
204 {
205 static InfoKey keyNumTable[] = { NUM_KEY_META_NODE, NUM_KEY_NET_CAP, NUM_KEY_DISCOVERY_TYPE,
206 NUM_KEY_MASTER_NODE_WEIGHT, NUM_KEY_P2P_ROLE, NUM_KEY_SLE_RANGE_CAP, NUM_KEY_USERID };
207 int32_t ret;
208 uint32_t i;
209 int32_t len = LNN_COMMON_LEN;
210 for (i = 0; i < sizeof(keyNumTable) / sizeof(InfoKey); i++) {
211 ret = LnnGetRemoteNumInfo(NODE1_NETWORK_ID, keyNumTable[i], &len);
212 EXPECT_EQ(ret, SOFTBUS_OK);
213 }
214 for (i = 0; i < sizeof(keyNumTable) / sizeof(InfoKey); i++) {
215 ret = LnnGetRemoteNumInfo(NODE2_NETWORK_ID, keyNumTable[i], &len);
216 EXPECT_NE(ret, SOFTBUS_OK);
217 }
218 }
219
220 /*
221 * @tc.name: LNN_GET_REMOTE_NUMNFO_BY_IFNAME_Test_002
222 * @tc.desc: lnn get remote num info by ifname test
223 * @tc.type: FUNC
224 * @tc.require:
225 */
226 HWTEST_F(LNNDisctributedLedgerTest, LNN_GET_REMOTE_NUMNFO_BY_IFNAME_Test_002, TestSize.Level1)
227 {
228 static InfoKey keyNumTable[] = { NUM_KEY_SESSION_PORT, NUM_KEY_AUTH_PORT, NUM_KEY_PROXY_PORT };
229 int32_t ret;
230 uint32_t i;
231 int32_t len = LNN_COMMON_LEN;
232 for (i = 0; i < sizeof(keyNumTable) / sizeof(InfoKey); i++) {
233 ret = LnnGetRemoteNumInfoByIfnameIdx(NODE1_NETWORK_ID, keyNumTable[i], &len, WLAN_IF);
234 EXPECT_EQ(ret, SOFTBUS_OK);
235 }
236 for (i = 0; i < sizeof(keyNumTable) / sizeof(InfoKey); i++) {
237 ret = LnnGetRemoteNumInfoByIfnameIdx(NODE2_NETWORK_ID, keyNumTable[i], &len, WLAN_IF);
238 EXPECT_NE(ret, SOFTBUS_OK);
239 }
240 }
241
242 /*
243 * @tc.name: LNN_GET_REMOTE_BYTEINFO_Test_003
244 * @tc.desc: lnn get remote byte info test
245 * @tc.type: FUNC
246 * @tc.require:
247 */
248 HWTEST_F(LNNDisctributedLedgerTest, LNN_GET_REMOTE_BYTEINFO_Test_003, TestSize.Level1)
249 {
250 unsigned char irk[LFINDER_IRK_LEN] = { 0 };
251 int32_t ret = LnnGetRemoteByteInfo(nullptr, BYTE_KEY_IRK, irk, LFINDER_IRK_LEN);
252 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
253 ret = LnnGetRemoteByteInfo(NODE1_NETWORK_ID, BYTE_KEY_IRK, nullptr, LFINDER_IRK_LEN);
254 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
255 ret = LnnGetRemoteByteInfo(NODE1_NETWORK_ID, BYTE_KEY_IRK, irk, LFINDER_IRK_LEN);
256 EXPECT_EQ(SOFTBUS_OK, ret);
257
258 unsigned char pubMac[LFINDER_MAC_ADDR_LEN] = { 0 };
259 ret = LnnGetRemoteByteInfo(nullptr, BYTE_KEY_PUB_MAC, pubMac, LFINDER_MAC_ADDR_LEN);
260 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
261 ret = LnnGetRemoteByteInfo(NODE1_NETWORK_ID, BYTE_KEY_PUB_MAC, nullptr, LFINDER_MAC_ADDR_LEN);
262 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
263 ret = LnnGetRemoteByteInfo(NODE1_NETWORK_ID, BYTE_KEY_PUB_MAC, pubMac, LFINDER_MAC_ADDR_LEN);
264 EXPECT_EQ(SOFTBUS_OK, ret);
265
266 unsigned char cipherKey[SESSION_KEY_LENGTH] = { 0 };
267 ret = LnnGetRemoteByteInfo(nullptr, BYTE_KEY_BROADCAST_CIPHER_KEY, cipherKey, SESSION_KEY_LENGTH);
268 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
269 ret = LnnGetRemoteByteInfo(NODE1_NETWORK_ID, BYTE_KEY_BROADCAST_CIPHER_KEY, nullptr, SESSION_KEY_LENGTH);
270 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
271 ret = LnnGetRemoteByteInfo(NODE1_NETWORK_ID, BYTE_KEY_BROADCAST_CIPHER_KEY, cipherKey, SESSION_KEY_LENGTH);
272 EXPECT_EQ(SOFTBUS_OK, ret);
273
274 unsigned char cipherIv[BROADCAST_IV_LEN] = { 0 };
275 ret = LnnGetRemoteByteInfo(nullptr, BYTE_KEY_BROADCAST_CIPHER_IV, cipherIv, BROADCAST_IV_LEN);
276 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
277 ret = LnnGetRemoteByteInfo(NODE1_NETWORK_ID, BYTE_KEY_BROADCAST_CIPHER_IV, nullptr, BROADCAST_IV_LEN);
278 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
279 ret = LnnGetRemoteByteInfo(NODE1_NETWORK_ID, BYTE_KEY_BROADCAST_CIPHER_IV, cipherIv, BROADCAST_IV_LEN);
280 EXPECT_EQ(SOFTBUS_OK, ret);
281 }
282
283 /*
284 * @tc.name: LNN_GET_CNN_CODE_Test_001
285 * @tc.desc: lnn get cnn code test
286 * @tc.type: FUNC
287 * @tc.require:
288 */
289 HWTEST_F(LNNDisctributedLedgerTest, LNN_GET_CNN_CODE_Test_001, TestSize.Level1)
290 {
291 DiscoveryType type = DISCOVERY_TYPE_WIFI;
292 short ret = LnnGetCnnCode(nullptr, type);
293 EXPECT_EQ(ret, INVALID_CONNECTION_CODE_VALUE);
294 ret = LnnGetCnnCode(NODE1_UUID, type);
295 EXPECT_EQ(ret, INVALID_CONNECTION_CODE_VALUE);
296 ret = LnnGetCnnCode(NODE2_UUID, type);
297 EXPECT_EQ(ret, INVALID_CONNECTION_CODE_VALUE);
298 }
299
300 /*
301 * @tc.name: LNN_UPDATE_NODE_INFO_Test_001
302 * @tc.desc: lnn update node info test
303 * @tc.type: FUNC
304 * @tc.require:
305 */
306 HWTEST_F(LNNDisctributedLedgerTest, LNN_UPDATE_NODE_INFO_Test_001, TestSize.Level1)
307 {
308 LnnEnhanceFuncList *pfnLnnEnhanceFuncList = LnnEnhanceFuncListGet();
309 pfnLnnEnhanceFuncList->lnnRetrieveDeviceInfo = LnnRetrieveDeviceInfo;
310 pfnLnnEnhanceFuncList->lnnSaveRemoteDeviceInfo = LnnSaveRemoteDeviceInfo;
311
312 NiceMock<LnnDisctributedNetLedgerInterfaceMock> mock;
313 EXPECT_CALL(mock, LnnRetrieveDeviceInfo).WillRepeatedly(Return(SOFTBUS_OK));
314 EXPECT_CALL(mock, LnnSaveRemoteDeviceInfo).WillRepeatedly(Return(SOFTBUS_OK));
315
316 NodeInfo newInfo;
317 (void)memset_s(&newInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
318 (void)strncpy_s(newInfo.deviceInfo.deviceUdid, UDID_BUF_LEN, NODE1_UDID, strlen(NODE1_UDID));
319 int32_t ret = LnnUpdateNodeInfo(&newInfo, CONNECTION_ADDR_BLE);
320 EXPECT_EQ(ret, SOFTBUS_OK);
321 (void)memcpy_s(newInfo.rpaInfo.peerIrk, LFINDER_IRK_LEN, "newpeerIrk", strlen("newpeerIrk"));
322 ret = LnnUpdateNodeInfo(&newInfo, CONNECTION_ADDR_BLE);
323 EXPECT_EQ(ret, SOFTBUS_OK);
324 (void)strcpy_s(newInfo.deviceInfo.deviceName, DEVICE_NAME_BUF_LEN, "newDeviceName");
325 ret = LnnUpdateNodeInfo(&newInfo, CONNECTION_ADDR_BLE);
326 EXPECT_EQ(ret, SOFTBUS_OK);
327 (void)memset_s(&newInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
328 (void)strncpy_s(newInfo.deviceInfo.deviceUdid, UDID_BUF_LEN, NODE2_UDID, strlen(NODE2_UDID));
329 ret = LnnUpdateNodeInfo(&newInfo, CONNECTION_ADDR_BLE);
330 EXPECT_EQ(ret, SOFTBUS_NETWORK_MAP_GET_FAILED);
331 }
332
333 /*
334 * @tc.name: LNN_UPDATE_META_INFO_Test_001
335 * @tc.desc: lnn update meta info test
336 * @tc.type: FUNC
337 * @tc.require:
338 */
339 HWTEST_F(LNNDisctributedLedgerTest, LNN_UPDATE_META_INFO_Test_001, TestSize.Level1)
340 {
341 int32_t ret = LnnAddMetaInfo(nullptr);
342 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
343 }
344
345 /*
346 * @tc.name: LNN_SET_NODE_OFFLINE_Test_001
347 * @tc.desc: lnn set node offline test
348 * @tc.type: FUNC
349 * @tc.require:
350 */
351 HWTEST_F(LNNDisctributedLedgerTest, LNN_SET_NODE_OFFLINE_Test_001, TestSize.Level1)
352 {
353 EXPECT_TRUE(REPORT_NONE == LnnSetNodeOffline(NODE1_UDID, CONNECTION_ADDR_WLAN, AUTH_ID));
354 EXPECT_TRUE(REPORT_NONE == LnnSetNodeOffline(NODE2_UDID, CONNECTION_ADDR_WLAN, AUTH_ID));
355 DfxRecordLnnSetNodeOfflineEnd(NODE1_UDID, 1, SOFTBUS_OK);
356 }
357
358 /*
359 * @tc.name: LNN_GET_BASIC_INFO_BY_UDID_Test_001
360 * @tc.desc: lnn get basic info by udid test
361 * @tc.type: FUNC
362 * @tc.require:
363 */
364 HWTEST_F(LNNDisctributedLedgerTest, LNN_GET_BASIC_INFO_BY_UDID_Test_001, TestSize.Level1)
365 {
366 NodeBasicInfo basicInfo;
367 (void)memset_s(&basicInfo, sizeof(NodeBasicInfo), 0, sizeof(NodeBasicInfo));
368 int32_t ret = LnnGetBasicInfoByUdid(NODE1_UDID, nullptr);
369 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
370 ret = LnnGetBasicInfoByUdid(NODE1_UDID, &basicInfo);
371 EXPECT_EQ(ret, SOFTBUS_OK);
372 }
373
374 /*
375 * @tc.name: LNN_CONVERT_DLID_Test_001
376 * @tc.desc: lnn convert dl id test
377 * @tc.type: FUNC
378 * @tc.require:
379 */
380
381 HWTEST_F(LNNDisctributedLedgerTest, LNN_CONVERT_DLID_Test_001, TestSize.Level1)
382 {
383 char buf[UDID_BUF_LEN] = { 0 };
384 int32_t ret = LnnConvertDlId(nullptr, CATEGORY_UDID, CATEGORY_UDID, buf, UDID_BUF_LEN);
385 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
386 ret = LnnConvertDlId(NODE1_UDID, CATEGORY_UDID, CATEGORY_UDID, buf, UDID_BUF_LEN);
387 EXPECT_EQ(ret, SOFTBUS_OK);
388 ret = LnnConvertDlId(NODE2_UDID, CATEGORY_UDID, CATEGORY_UDID, buf, UDID_BUF_LEN);
389 EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
390 ret = LnnConvertDlId(NODE2_UUID, CATEGORY_UUID, CATEGORY_UUID, buf, UDID_BUF_LEN);
391 EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
392 ret = LnnConvertDlId(NODE2_NETWORK_ID, CATEGORY_NETWORK_ID, CATEGORY_NETWORK_ID, buf, NETWORK_ID_BUF_LEN);
393 EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
394 }
395
396 /*
397 * @tc.name: LNN_SET_DLP2P_INFO_Test_001
398 * @tc.desc: lnn get lnn relation test
399 * @tc.type: FUNC
400 * @tc.require:
401 */
402 HWTEST_F(LNNDisctributedLedgerTest, LNN_SET_DLP2P_INFO_Test_001, TestSize.Level1)
403 {
404 P2pInfo info;
405 (void)memset_s(&info, sizeof(P2pInfo), 0, sizeof(P2pInfo));
406 (void)strncpy_s(info.p2pMac, MAC_LEN, P2P_MAC, strlen(P2P_MAC));
407 (void)strncpy_s(info.goMac, MAC_LEN, GO_MAC, strlen(GO_MAC));
408 info.p2pRole = P2P_ROLE;
409 bool ret = LnnSetDLP2pInfo(nullptr, &info);
410 EXPECT_FALSE(ret);
411 ret = LnnSetDLP2pInfo(NODE1_NETWORK_ID, &info);
412 EXPECT_TRUE(ret);
413 ret = LnnSetDLP2pInfo(NODE2_NETWORK_ID, &info);
414 EXPECT_FALSE(ret);
415 }
416
417 /*
418 * @tc.name: LNN_GET_NETWORKID_BYBTMAC_Test_001
419 * @tc.desc: lnn get neteorkId by bt mac test
420 * @tc.type: FUNC
421 * @tc.require:
422 */
423 HWTEST_F(LNNDisctributedLedgerTest, LNN_GET_NETWORKID_BYBTMAC_Test_001, TestSize.Level1)
424 {
425 char buf[NETWORK_ID_BUF_LEN] = { 0 };
426 int32_t ret = LnnGetNetworkIdByBtMac(nullptr, buf, NETWORK_ID_BUF_LEN);
427 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
428 ret = LnnGetNetworkIdByBtMac(NODE1_BT_MAC, buf, NETWORK_ID_BUF_LEN);
429 EXPECT_EQ(ret, SOFTBUS_OK);
430 ret = LnnGetNetworkIdByBtMac(NODE2_BT_MAC, buf, NETWORK_ID_BUF_LEN);
431 EXPECT_NE(ret, SOFTBUS_OK);
432 }
433
434 /*
435 * @tc.name: LNN_GET_NETWORKID_BY_UUID_Test_001
436 * @tc.desc: lnn get neteorkId by uuid test
437 * @tc.type: FUNC
438 * @tc.require:
439 */
440 HWTEST_F(LNNDisctributedLedgerTest, LNN_GET_NETWORKID_BY_UUID_Test_001, TestSize.Level1)
441 {
442 char buf[UUID_BUF_LEN] = { 0 };
443 int32_t ret = LnnGetNetworkIdByUuid(nullptr, buf, UUID_BUF_LEN);
444 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
445 ret = LnnGetNetworkIdByUuid(NODE1_UUID, buf, NETWORK_ID_BUF_LEN);
446 EXPECT_EQ(ret, SOFTBUS_OK);
447 ret = LnnGetNetworkIdByUuid(NODE2_UUID, buf, NETWORK_ID_BUF_LEN);
448 EXPECT_NE(ret, SOFTBUS_OK);
449 }
450
451 /*
452 * @tc.name: LNN_GET_NETWORKID_BY_UDID_Test_001
453 * @tc.desc: lnn get neteorkId by udid test
454 * @tc.type: FUNC
455 * @tc.require:
456 */
457 HWTEST_F(LNNDisctributedLedgerTest, LNN_GET_NETWORKID_BY_UDID_Test_001, TestSize.Level1)
458 {
459 char buf[UDID_BUF_LEN] = { 0 };
460 int32_t ret = LnnGetNetworkIdByUdid(nullptr, buf, UDID_BUF_LEN);
461 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
462 ret = LnnGetNetworkIdByUdid(NODE1_UDID, buf, UDID_BUF_LEN);
463 EXPECT_EQ(ret, SOFTBUS_OK);
464 ret = LnnGetNetworkIdByUdid(NODE2_UDID, buf, UDID_BUF_LEN);
465 EXPECT_NE(ret, SOFTBUS_OK);
466 }
467
468 /*
469 * @tc.name: LNN_GET_DLHEARTBEAT_TIMER_STAMP_Test_001
470 * @tc.desc: lnn get dl heartbeat time stamp test
471 * @tc.type: FUNC
472 * @tc.require:
473 */
474 HWTEST_F(LNNDisctributedLedgerTest, LNN_GET_DLHEARTBEAT_TIMER_STAMP_Test_001, TestSize.Level1)
475 {
476 uint64_t timeStamp;
477 int32_t ret = LnnGetDLHeartbeatTimestamp(NODE1_NETWORK_ID, &timeStamp);
478 EXPECT_EQ(ret, SOFTBUS_OK);
479 ret = LnnGetDLHeartbeatTimestamp(NODE2_NETWORK_ID, &timeStamp);
480 EXPECT_NE(ret, SOFTBUS_OK);
481 }
482
483 /*
484 * @tc.name: LNN_SET_DLHEARTBEAT_TIMER_STAMP_Test_001
485 * @tc.desc: lnn set dl heartbeat time stamp test
486 * @tc.type: FUNC
487 * @tc.require:
488 */
489 HWTEST_F(LNNDisctributedLedgerTest, LNN_SET_DLHEARTBEAT_TIMER_STAMP_Test_001, TestSize.Level1)
490 {
491 uint64_t timeStamp = NEW_TIME_STAMP;
492 int32_t ret = LnnSetDLHeartbeatTimestamp(NODE1_NETWORK_ID, timeStamp);
493 EXPECT_EQ(ret, SOFTBUS_OK);
494 ret = LnnSetDLHeartbeatTimestamp(NODE2_NETWORK_ID, timeStamp);
495 EXPECT_NE(ret, SOFTBUS_OK);
496 }
497
498 /*
499 * @tc.name: LNN_SET_DLCONN_CAPABILITY_Test_001
500 * @tc.desc: lnn set dl conn capability test
501 * @tc.type: FUNC
502 * @tc.require:
503 */
504 HWTEST_F(LNNDisctributedLedgerTest, LNN_SET_DLCONN_CAPABILITY_Test_001, TestSize.Level1)
505 {
506 uint64_t connCapability = CAPABILITY;
507 int32_t ret = LnnSetDLConnCapability(NODE2_NETWORK_ID, connCapability);
508 EXPECT_NE(ret, SOFTBUS_OK);
509 }
510
511 /*
512 * @tc.name: LNN_SET_DLNODE_ADDR_Test_001
513 * @tc.desc: lnn set dl node addr test
514 * @tc.type: FUNC
515 * @tc.require:
516 */
517 HWTEST_F(LNNDisctributedLedgerTest, LNN_SET_DLNODE_ADDR_Test_001, TestSize.Level1)
518 {
519 int32_t ret = LnnSetDLNodeAddr(NODE1_NETWORK_ID, CATEGORY_NETWORK_ID, NODE_ADDRESS);
520 EXPECT_EQ(ret, SOFTBUS_OK);
521 ret = LnnSetDLNodeAddr(NODE2_NETWORK_ID, CATEGORY_NETWORK_ID, NODE_ADDRESS);
522 EXPECT_NE(ret, SOFTBUS_OK);
523 }
524
525 /*
526 * @tc.name: LNN_GET_ONLINE_NODE_BY_UDID_HASH_Test_001
527 * @tc.desc: lnn get online node by udid hash test
528 * @tc.type: FUNC
529 * @tc.require:
530 */
531 HWTEST_F(LNNDisctributedLedgerTest, LNN_GET_ONLINE_NODE_BY_UDID_HASH_Test_001, TestSize.Level1)
532 {
533 EXPECT_TRUE(LnnGetOnlineNodeByUdidHash(RECV_UDID_HASH) == nullptr);
534 }
535
536 /*
537 * @tc.name: LNN_GET_DATA_CHANGE_FLAG_Test_001
538 * @tc.desc: lnn get data change flag test
539 * @tc.type: FUNC
540 * @tc.require:
541 */
542 HWTEST_F(LNNDisctributedLedgerTest, LNN_GET_DATA_CHANGE_FLAG_Test_001, TestSize.Level1)
543 {
544 int16_t info = 0;
545 int32_t ret = LnnGetRemoteNum16Info(NODE1_NETWORK_ID, NUM_KEY_DATA_CHANGE_FLAG, &info);
546 EXPECT_EQ(ret, SOFTBUS_OK);
547 ret = LnnGetRemoteNum16Info(NODE2_NETWORK_ID, NUM_KEY_DATA_CHANGE_FLAG, &info);
548 EXPECT_EQ(ret, SOFTBUS_NETWORK_GET_NODE_INFO_ERR);
549 ret = LnnGetRemoteNum16Info(NODE2_NETWORK_ID, NUM_KEY_DATA_CHANGE_FLAG, nullptr);
550 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
551 }
552
553 /*
554 * @tc.name: LNN_CONVERT_DLID_TO_UDID_Test_001
555 * @tc.desc: lnn convert dlid to udid test
556 * @tc.type: FUNC
557 * @tc.require:
558 */
559 HWTEST_F(LNNDisctributedLedgerTest, LNN_CONVERT_DLID_TO_UDID_Test_001, TestSize.Level1)
560 {
561 EXPECT_TRUE(LnnConvertDLidToUdid(nullptr, CATEGORY_NETWORK_ID) == nullptr);
562 LnnConvertDLidToUdid(NODE1_NETWORK_ID, CATEGORY_NETWORK_ID);
563 EXPECT_TRUE(LnnConvertDLidToUdid(NODE2_NETWORK_ID, CATEGORY_NETWORK_ID) == nullptr);
564 }
565
566 /*
567 * @tc.name: LNN_GET_LNN_RELATION_Test_001
568 * @tc.desc: lnn get lnn relation test
569 * @tc.type: FUNC
570 * @tc.require:
571 */
572 HWTEST_F(LNNDisctributedLedgerTest, LNN_GET_LNN_RELATION_Test_001, TestSize.Level1)
573 {
574 uint8_t relation[CONNECTION_ADDR_MAX] = { 0 };
575 int32_t ret = LnnGetLnnRelation(nullptr, CATEGORY_UDID, relation, CONNECTION_ADDR_MAX);
576 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
577 ret = LnnGetLnnRelation(NODE1_UDID, CATEGORY_UDID, relation, CONNECTION_ADDR_MAX);
578 EXPECT_EQ(ret, SOFTBUS_OK);
579 ret = LnnGetLnnRelation(NODE2_UDID, CATEGORY_UDID, relation, CONNECTION_ADDR_MAX);
580 EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
581 }
582
583 /*
584 * @tc.name: LNN_SET_DL_DEVICE_INFO_NAME_Test_001
585 * @tc.desc: lnn set dl device info name test
586 * @tc.type: FUNC
587 * @tc.require:
588 */
589 HWTEST_F(LNNDisctributedLedgerTest, LNN_SET_DL_DEVICE_INFO_NAME_Test_001, TestSize.Level1)
590 {
591 bool ret = LnnSetDLDeviceInfoName(nullptr, nullptr);
592 EXPECT_FALSE(ret);
593 ret = LnnSetDLDeviceInfoName(NODE1_UDID, NODE1_DEVICE_NAME);
594 EXPECT_TRUE(ret);
595 ret = LnnSetDLDeviceInfoName(NODE2_UDID, NODE2_DEVICE_NAME);
596 EXPECT_FALSE(ret);
597 }
598
599 /*
600 * @tc.name: GET_NODEINFO_FORMMAP_Test_001
601 * @tc.desc: get node info from map test
602 * @tc.type: FUNC
603 * @tc.require:
604 */
605 HWTEST_F(LNNDisctributedLedgerTest, GET_NODEINFO_FORMMAP_Test_001, TestSize.Level1)
606 {
607 (void)GetCurrentTime();
608 NodeInfo *res = GetNodeInfoFromMap(nullptr, nullptr);
609 EXPECT_TRUE(res == nullptr);
610 }
611
612 /*
613 * @tc.name: INIT_DISTRIBUTED_INFO_Test_001
614 * @tc.desc: init distributed info test
615 * @tc.type: FUNC
616 * @tc.require:
617 */
618 HWTEST_F(LNNDisctributedLedgerTest, INIT_DISTRIBUTED_INFO_Test_001, TestSize.Level1)
619 {
620 int32_t ret = InitDistributedInfo(nullptr);
621 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
622 ret = InitConnectionCode(nullptr);
623 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
624 (void)DeinitConnectionCode(nullptr);
625 }
626
627 /*
628 * @tc.name: NEW_BRBLE_DISCOVERED_Test_001
629 * @tc.desc: new br ble discovered test
630 * @tc.type: FUNC
631 * @tc.require:
632 */
633 HWTEST_F(LNNDisctributedLedgerTest, NEW_BRBLE_DISCOVERED_Test_001, TestSize.Level1)
634 {
635 NodeInfo oldInfo;
636 (void)memset_s(&oldInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
637 NodeInfo newInfo;
638 (void)memset_s(&newInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
639 (void)NewWifiDiscovered(nullptr, nullptr);
640 (void)NewWifiDiscovered(&oldInfo, &newInfo);
641 (void)RetainOfflineCode(nullptr, nullptr);
642 (void)ConvertNodeInfoToBasicInfo(nullptr, nullptr);
643 bool ret = IsNetworkIdChanged(nullptr, nullptr);
644 EXPECT_FALSE(ret);
645 ret = IsNetworkIdChanged(&newInfo, &oldInfo);
646 EXPECT_FALSE(ret);
647 }
648
649 /*
650 * @tc.name: IS_META_NODE_Test_001
651 * @tc.desc: is meta node test
652 * @tc.type: FUNC
653 * @tc.require:
654 */
655 HWTEST_F(LNNDisctributedLedgerTest, IS_META_NODE_Test_001, TestSize.Level1)
656 {
657 NodeInfo info;
658 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
659 info.metaInfo.isMetaNode = true;
660 bool ret = IsMetaNode(nullptr);
661 EXPECT_FALSE(ret);
662 ret = IsMetaNode(&info);
663 EXPECT_TRUE(ret);
664 }
665
666 /*
667 * @tc.name: LNN_GET_NODEINFO_BYID_Test_001
668 * @tc.desc: lnn get node info by id test
669 * @tc.type: FUNC
670 * @tc.require:
671 */
672 HWTEST_F(LNNDisctributedLedgerTest, LNN_GET_NODEINFO_BYID_Test_001, TestSize.Level1)
673 {
674 INodeStateCb callBack;
675 IdCategory type = CATEGORY_UDID;
676 NodeInfo *ret = LnnGetNodeInfoById(nullptr, type);
677 EXPECT_EQ(ret, nullptr);
678 callBack.onNodeOnline = nullptr;
679 (void)PostOnlineNodesToCb(&callBack);
680 callBack.onNodeOnline = TestFunc;
681 (void)PostOnlineNodesToCb(&callBack);
682 }
683
684 /*
685 * @tc.name: LNN_GET_REMOTE_NODE_Test_001
686 * @tc.desc: lnn get remote node info by key test
687 * @tc.type: FUNC
688 * @tc.require:
689 */
690 HWTEST_F(LNNDisctributedLedgerTest, LNN_GET_REMOTE_NODE_Test_001, TestSize.Level1)
691 {
692 int32_t ret = LnnGetRemoteNodeInfoByKey(nullptr, nullptr);
693 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
694 const char *key = "dsoftBus";
695 NodeInfo info;
696 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
697 ret = LnnGetRemoteNodeInfoByKey(key, &info);
698 EXPECT_NE(ret, SOFTBUS_OK);
699 }
700
701 /*
702 * @tc.name: DLGET_DEVICE_TYPEID_Test_001
703 * @tc.desc: dl get node ble mac test
704 * @tc.type: FUNC
705 * @tc.require:
706 */
707 HWTEST_F(LNNDisctributedLedgerTest, DLGET_DEVICE_TYPEID_Test_001, TestSize.Level1)
708 {
709 const char *networkId = "softBus";
710 char bleMac = '0';
711 uint32_t len = 0;
712 int32_t ret = DlGetDeviceTypeId(nullptr, true, nullptr, len);
713 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
714 ret = DlGetNodeBleMac(nullptr, true, nullptr, len);
715 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
716 (void)LnnUpdateNodeBleMac(nullptr, nullptr, len);
717 (void)LnnUpdateNodeBleMac(networkId, &bleMac, len);
718 }
719
720 /*
721 * @tc.name: DL_GET_WIFICFG_Test_001
722 * @tc.desc: dl get node ble mac test
723 * @tc.type: FUNC
724 * @tc.require:
725 */
726 HWTEST_F(LNNDisctributedLedgerTest, DL_GET_WIFICFG_Test_001, TestSize.Level1)
727 {
728 uint32_t len = 0;
729 int32_t ret = DlGetWifiCfg(nullptr, true, nullptr, len);
730 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
731 ret = DlGetChanList5g(nullptr, true, nullptr, len);
732 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
733 ret = DlGetP2pRole(nullptr, true, nullptr, len);
734 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
735 ret = DlGetStateVersion(nullptr, true, nullptr, len);
736 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
737 ret = DlGetStaFrequency(nullptr, true, nullptr, len);
738 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
739 len = LNN_COMMON_LEN;
740 ret = DlGetStateVersion(nullptr, true, nullptr, len);
741 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
742 ret = DlGetStaFrequency(nullptr, true, nullptr, len);
743 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
744 ret = DlGetNodeDataChangeFlag(nullptr, true, nullptr, len);
745 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
746 len = DATA_CHANGE_FLAG_BUF_LEN;
747 ret = DlGetNodeDataChangeFlag(nullptr, true, nullptr, len);
748 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
749 ret = DlGetMasterWeight(nullptr, true, nullptr, len);
750 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
751 ret = DlGetNetType(nullptr, true, nullptr, len);
752 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
753 ret = DlGetProxyPort(nullptr, true, nullptr, len, WLAN_IF);
754 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
755 ret = DlGetSessionPort(nullptr, true, nullptr, len, WLAN_IF);
756 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
757 ret = DlGetAuthPort(nullptr, true, nullptr, len, WLAN_IF);
758 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
759 }
760
761 /*
762 * @tc.name: DLGET_NODETTLV_NEGOFLAG_Test_001
763 * @tc.desc: dl get node tlv nego flag test
764 * @tc.type: FUNC
765 * @tc.require:
766 */
767 HWTEST_F(LNNDisctributedLedgerTest, DLGET_NODETTLV_NEGOFLAG_Test_001, TestSize.Level1)
768 {
769 uint32_t len = 0;
770 int32_t ret = DlGetNodeTlvNegoFlag(nullptr, true, nullptr, len);
771 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
772 ret = DlGetAccountHash(nullptr, true, nullptr, len);
773 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
774 len = sizeof(bool);
775 ret = DlGetNodeTlvNegoFlag(nullptr, true, nullptr, len);
776 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
777 len = SHA_256_HASH_LEN;
778 ret = DlGetAccountHash(nullptr, true, nullptr, len);
779 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
780 (void)DestroyCnnCodeKey(nullptr);
781 (void)DeinitDistributedInfo(nullptr);
782 }
783
784 /*
785 * @tc.name: ADD_CNN_CODE_Test_001
786 * @tc.desc: add cnn code test
787 * @tc.type: FUNC
788 * @tc.require:
789 */
790 HWTEST_F(LNNDisctributedLedgerTest, ADD_CNN_CODE_Test_001, TestSize.Level1)
791 {
792 Map cnnCode;
793 const char *uuid = "softBus";
794 DiscoveryType type = DISCOVERY_TYPE_WIFI;
795 int64_t authSeqNum = 0;
796 int32_t ret = AddCnnCode(&cnnCode, nullptr, type, authSeqNum);
797 EXPECT_EQ(ret, SOFTBUS_MEM_ERR);
798 ret = AddCnnCode(&cnnCode, uuid, type, authSeqNum);
799 EXPECT_EQ(ret, SOFTBUS_OK);
800
801 char *key = CreateCnnCodeKey(uuid, type);
802 EXPECT_NE(key, nullptr);
803 short* code = (short *)LnnMapGet(&cnnCode, key);
804 EXPECT_NE(code, nullptr);
805
806 (void)RemoveCnnCode(&cnnCode, nullptr, type);
807 (void)RemoveCnnCode(&cnnCode, uuid, type);
808
809 code = (short *)LnnMapGet(&cnnCode, key);
810 EXPECT_EQ(code, nullptr);
811 }
812
813 /*
814 * @tc.name: NOTIFY_MIGRATE_UPGRADE_Test_001
815 * @tc.desc: notify migrate upgrade test
816 * @tc.type: FUNC
817 * @tc.require:
818 */
819 HWTEST_F(LNNDisctributedLedgerTest, NOTIFY_MIGRATE_UPGRADE_Test_001, TestSize.Level1)
820 {
821 NodeInfo info;
822 memset_s(info.deviceInfo.deviceUdid, sizeof(info.deviceInfo.deviceUdid), '\0', sizeof(info.deviceInfo.deviceUdid));
823 (void)NotifyMigrateUpgrade(&info);
824 int32_t ret = LnnUpdateAccountInfo(nullptr);
825 EXPECT_NE(ret, SOFTBUS_OK);
826 }
827
828 /*
829 * @tc.name: LNN_UPDATE_GROUPTYPE_Test_001
830 * @tc.desc: lnn update group type test
831 * @tc.type: FUNC
832 * @tc.require:
833 */
834 HWTEST_F(LNNDisctributedLedgerTest, LNN_UPDATE_GROUPTYPE_Test_001, TestSize.Level1)
835 {
836 NodeInfo info;
837 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
838 int32_t ret = LnnUpdateGroupType(nullptr);
839 EXPECT_NE(ret, SOFTBUS_OK);
840 char str[] = "softBus";
841 strcpy_s(info.deviceInfo.deviceUdid, sizeof(str), str);
842 ret = LnnUpdateGroupType(&info);
843 EXPECT_EQ(ret, SOFTBUS_NETWORK_MAP_GET_FAILED);
844
845 const char *udid = "softBus";
846 (void)NotifyMigrateDegrade(udid);
847 }
848
849 /*
850 * @tc.name: LNN_GET_REMOTE_BYTEINFO_Test_001
851 * @tc.desc: lnn get remote byte info test
852 * @tc.type: FUNC
853 * @tc.require:
854 */
855 HWTEST_F(LNNDisctributedLedgerTest, LNN_GET_REMOTE_BYTEINFO_Test_001, TestSize.Level1)
856 {
857 const char *networkId = "softBus";
858 InfoKey key = BYTE_KEY_END;
859 uint8_t info;
860 uint32_t len = 0;
861 int32_t ret = LnnGetRemoteByteInfo(nullptr, key, &info, len);
862 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
863 ret = LnnGetRemoteByteInfo(networkId, key, nullptr, len);
864 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
865 ret = LnnGetRemoteByteInfo(networkId, key, &info, len);
866 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
867 key = BYTE_KEY_BEGIN;
868 ret = LnnGetRemoteByteInfo(networkId, key, &info, len);
869 EXPECT_NE(ret, SOFTBUS_OK);
870 }
871
872 /*
873 * @tc.name: LNN_ISLSA_NODE_Test_001
874 * @tc.desc: lnn is LSA node test
875 * @tc.type: FUNC
876 * @tc.require:
877 */
878 HWTEST_F(LNNDisctributedLedgerTest, LNN_ISLSA_NODE_Test_001, TestSize.Level1)
879 {
880 NodeBasicInfo info;
881 memset_s(info.networkId, sizeof(info.networkId), '\0', sizeof(info.networkId));
882 bool ret = LnnIsLSANode(&info);
883 EXPECT_FALSE(ret);
884
885 int32_t nodeNum = 0;
886 int32_t res = LnnGetAllOnlineNodeNum(nullptr);
887 EXPECT_TRUE(res == SOFTBUS_INVALID_PARAM);
888 res = LnnGetAllOnlineNodeNum(&nodeNum);
889 EXPECT_TRUE(res == SOFTBUS_OK);
890 }
891
892 /*
893 * @tc.name: LNN_GETNETWORKID_BYUDIDHASH_Test_001
894 * @tc.desc: lnn get network id by udid hash test
895 * @tc.type: FUNC
896 * @tc.require:
897 */
898 HWTEST_F(LNNDisctributedLedgerTest, LNN_GETNETWORKID_BYUDIDHASH_Test_001, TestSize.Level1)
899 {
900 uint8_t udidHash[UDID_HASH_LEN] = {0};
901 char buf = '0';
902 uint32_t len = 0;
903 int32_t ret = LnnGetNetworkIdByUdidHash(nullptr, len, nullptr, len, true);
904 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
905 ret = LnnGetNetworkIdByUdidHash(udidHash, UDID_HASH_LEN, &buf, len, true);
906 EXPECT_NE(ret, SOFTBUS_OK);
907 }
908
909 /*
910 * @tc.name: LNN_GETDL_ONLINETIMESTAMP_Test_001
911 * @tc.desc: lnn get DL online timestamp test
912 * @tc.type: FUNC
913 * @tc.require:
914 */
915 HWTEST_F(LNNDisctributedLedgerTest, LNN_GETDL_ONLINETIMESTAMP_Test_001, TestSize.Level1)
916 {
917 uint64_t timestamp = 0;
918 int32_t ret = LnnGetDLOnlineTimestamp(nullptr, ×tamp);
919 EXPECT_NE(ret, SOFTBUS_OK);
920 }
921
922 /*
923 * @tc.name: LNN_SETDL_BATTERYINFO_Test_001
924 * @tc.desc: lnn set DL battery info test
925 * @tc.type: FUNC
926 * @tc.require:
927 */
928 HWTEST_F(LNNDisctributedLedgerTest, LNN_SETDL_BATTERYINFO_Test_001, TestSize.Level1)
929 {
930 const char *networkId = "softBus";
931 BatteryInfo info;
932 (void)memset_s(&info, sizeof(BatteryInfo), 0, sizeof(BatteryInfo));
933 int32_t ret = LnnSetDLBatteryInfo(nullptr, &info);
934 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
935 ret = LnnSetDLBatteryInfo(networkId, &info);
936 EXPECT_NE(ret, SOFTBUS_OK);
937 }
938
939 /*
940 * @tc.name: LNN_SETDL_BSSTRANSINFO_Test_001
941 * @tc.desc: lnn set DL bss trans info test
942 * @tc.type: FUNC
943 * @tc.require:
944 */
945 HWTEST_F(LNNDisctributedLedgerTest, LNN_SETDL_BSSTRANSINFO_Test_001, TestSize.Level1)
946 {
947 const char *networkId = "softBus";
948 BssTransInfo info;
949 (void)memset_s(&info, sizeof(BssTransInfo), 0, sizeof(BssTransInfo));
950 int32_t ret = LnnSetDLBssTransInfo(nullptr, &info);
951 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
952 ret = LnnSetDLBssTransInfo(networkId, &info);
953 EXPECT_NE(ret, SOFTBUS_OK);
954 }
955
956 /*
957 * @tc.name: LNN_SETDL_PROXYPORT_Test_001
958 * @tc.desc: lnn set DL proxy port test
959 * @tc.type: FUNC
960 * @tc.require:
961 */
962 HWTEST_F(LNNDisctributedLedgerTest, LNN_SETDL_PROXYPORT_Test_001, TestSize.Level1)
963 {
964 IdCategory type = CATEGORY_NETWORK_ID;
965 int32_t proxyPort = 0;
966 int32_t ret = LnnSetDLProxyPort(nullptr, type, proxyPort);
967 EXPECT_NE(ret, SOFTBUS_OK);
968 }
969
970 /*
971 * @tc.name: LNN_SETDL_SESSIONPORT_Test_001
972 * @tc.desc: lnn set DL session port test
973 * @tc.type: FUNC
974 * @tc.require:
975 */
976 HWTEST_F(LNNDisctributedLedgerTest, LNN_SETDL_SESSIONPORT_Test_001, TestSize.Level1)
977 {
978 IdCategory type = CATEGORY_NETWORK_ID;
979 int32_t sessionPort = 0;
980 int32_t ret = LnnSetDLSessionPort(nullptr, type, sessionPort);
981 EXPECT_NE(ret, SOFTBUS_OK);
982 }
983
984 /*
985 * @tc.name: LNN_SETDL_AUTHPORT_Test_001
986 * @tc.desc: lnn set DL auth port test
987 * @tc.type: FUNC
988 * @tc.require:
989 */
990 HWTEST_F(LNNDisctributedLedgerTest, LNN_SETDL_AUTHPORT_Test_001, TestSize.Level1)
991 {
992 const char *id = "softBus";
993 IdCategory type = CATEGORY_NETWORK_ID;
994 int32_t authPort = 0;
995 int32_t ret = LnnSetDLAuthPort(nullptr, type, authPort);
996 EXPECT_NE(ret, SOFTBUS_OK);
997 ret = LnnSetDLAuthPort(id, type, authPort);
998 EXPECT_NE(ret, SOFTBUS_OK);
999 }
1000
1001 /*
1002 * @tc.name: SOFTBUS_DUMPBUSCENTER_Test_001
1003 * @tc.desc: softbus dump buscenter remote device info test
1004 * @tc.type: FUNC
1005 * @tc.require:
1006 */
1007 HWTEST_F(LNNDisctributedLedgerTest, SOFTBUS_DUMPBUSCENTER_Test_001, TestSize.Level1)
1008 {
1009 int32_t fd = 0;
1010 int32_t ret = SoftBusDumpBusCenterRemoteDeviceInfo(fd);
1011 EXPECT_EQ(ret, SOFTBUS_OK);
1012 }
1013
1014 /*
1015 * @tc.name: LNN_GETREMOTE_BOOLINFO_Test_001
1016 * @tc.desc: lnn get remote bool info test
1017 * @tc.type: FUNC
1018 * @tc.require:
1019 */
1020 HWTEST_F(LNNDisctributedLedgerTest, LNN_GETREMOTE_BOOLINFO_Test_001, TestSize.Level1)
1021 {
1022 const char *networkId = "softBus";
1023 InfoKey key = BOOL_KEY_END;
1024 bool info = false;
1025 int32_t ret = LnnGetRemoteBoolInfo(nullptr, key, nullptr);
1026 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1027 ret = LnnGetRemoteBoolInfo(networkId, key, nullptr);
1028 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1029 ret = LnnGetRemoteBoolInfo(networkId, key, &info);
1030 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1031 key = BOOL_KEY_BEGIN;
1032 ret = LnnGetRemoteBoolInfo(networkId, key, &info);
1033 EXPECT_NE(ret, SOFTBUS_OK);
1034 }
1035
1036 /*
1037 * @tc.name: LNN_GETREMOTE_NUMU64INFO_Test_001
1038 * @tc.desc: lnn get remote bool info test
1039 * @tc.type: FUNC
1040 * @tc.require:
1041 */
1042 HWTEST_F(LNNDisctributedLedgerTest, LNN_GETREMOTE_NUMU64INFO_Test_001, TestSize.Level1)
1043 {
1044 const char *networkId = "softBus";
1045 InfoKey key = BOOL_KEY_END;
1046 uint64_t info = 0;
1047 int32_t ret = LnnGetRemoteNumU64Info(nullptr, key, nullptr);
1048 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1049 ret = LnnGetRemoteNumU64Info(networkId, key, nullptr);
1050 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1051 ret = LnnGetRemoteNumU64Info(networkId, key, &info);
1052 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1053 key = BOOL_KEY_BEGIN;
1054 ret = LnnGetRemoteNumU64Info(networkId, key, &info);
1055 EXPECT_NE(ret, SOFTBUS_OK);
1056 }
1057
1058 /*
1059 * @tc.name: LNN_GETREMOTE_NODEINFO_Test_001
1060 * @tc.desc: lnn get remote node info by id test
1061 * @tc.type: FUNC
1062 * @tc.require:
1063 */
1064 HWTEST_F(LNNDisctributedLedgerTest, LNN_GETREMOTE_NODEINFO_Test_001, TestSize.Level1)
1065 {
1066 const char *networkId = "softBus";
1067 IdCategory type = CATEGORY_NETWORK_ID;
1068 NodeInfo info;
1069 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
1070 int32_t ret = LnnGetRemoteNodeInfoById(networkId, type, &info);
1071 EXPECT_NE(ret, SOFTBUS_OK);
1072 }
1073
1074 /*
1075 * @tc.name: LNN_REFRESH_DEVICEONLINE_ANDINFO_Test_001
1076 * @tc.desc: lnn refresh device online state and devid info test
1077 * @tc.type: FUNC
1078 * @tc.require:
1079 */
1080 HWTEST_F(LNNDisctributedLedgerTest, LNN_REFRESH_DEVICEONLINE_ANDINFO_Test_001, TestSize.Level1)
1081 {
1082 DeviceInfo device;
1083 (void)memset_s(&device, sizeof(DeviceInfo), 0, sizeof(DeviceInfo));
1084 InnerDeviceInfoAddtions additions;
1085 (void)memset_s(&additions, sizeof(InnerDeviceInfoAddtions), 0, sizeof(InnerDeviceInfoAddtions));
1086 (void)LnnRefreshDeviceOnlineStateAndDevIdInfo(nullptr, &device, &additions);
1087
1088 (void)memset_s(device.devId, sizeof(device.devId), '\0', sizeof(device.devId));
1089 additions.medium = COAP;
1090 device.isOnline = true;
1091 (void)LnnRefreshDeviceOnlineStateAndDevIdInfo(nullptr, &device, &additions);
1092 EXPECT_TRUE(device.isOnline == false);
1093
1094 additions.medium = BLE;
1095 device.isOnline = true;
1096 (void)LnnRefreshDeviceOnlineStateAndDevIdInfo(nullptr, &device, &additions);
1097 EXPECT_TRUE(device.isOnline == false);
1098 }
1099
1100 /*
1101 * @tc.name: DLGET_FEATURE_CAP_Test_001
1102 * @tc.desc: dl get feature cap test
1103 * @tc.type: FUNC
1104 * @tc.require:
1105 */
1106 HWTEST_F(LNNDisctributedLedgerTest, DLGET_FEATURE_CAP_Test_001, TestSize.Level1)
1107 {
1108 const char *networkId = "softBus";
1109 uint32_t len = 0;
1110 int32_t ret = DlGetFeatureCap(networkId, true, nullptr, len);
1111 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1112 len = LNN_COMMON_LEN_64;
1113 ret = DlGetFeatureCap(networkId, true, nullptr, len);
1114 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1115 }
1116
1117 /*
1118 * @tc.name: LNN_SET_DLWIFIDIRECT_ADDR_Test_001
1119 * @tc.desc: lnn get lnn relation test
1120 * @tc.type: FUNC
1121 * @tc.require:
1122 */
1123 HWTEST_F(LNNDisctributedLedgerTest, LNN_SET_DLWIFIDIRECT_ADDR_Test_001, TestSize.Level1)
1124 {
1125 bool ret = LnnSetDLWifiDirectAddr(NODE1_NETWORK_ID, nullptr);
1126 EXPECT_FALSE(ret);
1127 char wifiDirectAddr1[MAC_LEN] = "11223344556677889";
1128 ret = LnnSetDLWifiDirectAddr(nullptr, wifiDirectAddr1);
1129 EXPECT_FALSE(ret);
1130 ret = LnnSetDLWifiDirectAddr(NODE1_NETWORK_ID, wifiDirectAddr1);
1131 EXPECT_TRUE(ret);
1132 ret = LnnSetDLWifiDirectAddr(NODE2_NETWORK_ID, wifiDirectAddr1);
1133 EXPECT_FALSE(ret);
1134
1135 char wifiDirectAddr2[MAC_LEN] = "11223344";
1136 ret = LnnSetDLWifiDirectAddr(nullptr, wifiDirectAddr2);
1137 EXPECT_FALSE(ret);
1138 ret = LnnSetDLWifiDirectAddr(NODE1_NETWORK_ID, wifiDirectAddr2);
1139 EXPECT_TRUE(ret);
1140 ret = LnnSetDLWifiDirectAddr(NODE2_NETWORK_ID, wifiDirectAddr2);
1141 EXPECT_FALSE(ret);
1142 }
1143
1144 /*
1145 * @tc.name: DLGET_STATIC_CAP_Test_001
1146 * @tc.desc: dl get static cap test
1147 * @tc.type: FUNC
1148 * @tc.require:
1149 */
1150 HWTEST_F(LNNDisctributedLedgerTest, DLGET_STATIC_CAP_Test_001, TestSize.Level1)
1151 {
1152 uint32_t len = 0;
1153 int32_t ret = DlGetStaticCap(nullptr, true, nullptr, len);
1154 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1155 len = STATIC_CAP_LEN + 1;
1156 ret = DlGetStaticCap(nullptr, true, nullptr, STATIC_CAP_LEN + 1);
1157 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1158 const char *networkId = "softbus";
1159 ret = DlGetStaticCap(networkId, true, nullptr, STATIC_CAP_LEN + 1);
1160 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1161 }
1162
1163 /*
1164 * @tc.name: DLGET_STATIC_CAP_LEN_Test_001
1165 * @tc.desc: dl get static cap len test
1166 * @tc.type: FUNC
1167 * @tc.require:
1168 */
1169 HWTEST_F(LNNDisctributedLedgerTest, DLGET_STATIC_CAP_LEN_Test_001, TestSize.Level1)
1170 {
1171 uint32_t len = 0;
1172 int32_t ret = DlGetStaticCapLen(nullptr, true, nullptr, len);
1173 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1174 len = STATIC_CAP_LEN + 1;
1175 ret = DlGetStaticCapLen(nullptr, true, nullptr, STATIC_CAP_LEN + 1);
1176 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1177 const char *networkId = "softbus";
1178 ret = DlGetStaticCapLen(networkId, true, nullptr, STATIC_CAP_LEN + 1);
1179 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1180 }
1181
1182 /*
1183 * @tc.name: DLGET_REMOTE_PTK_Test_001
1184 * @tc.desc: dl get remote ptk test
1185 * @tc.type: FUNC
1186 * @tc.require:
1187 */
1188 HWTEST_F(LNNDisctributedLedgerTest, DLGET_REMOTE_PTK_Test_001, TestSize.Level1)
1189 {
1190 uint32_t len = 0;
1191 int32_t ret = DlGetRemotePtk(nullptr, true, nullptr, len);
1192 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1193 len = STATIC_CAP_LEN + 1;
1194 ret = DlGetRemotePtk(nullptr, true, nullptr, STATIC_CAP_LEN + 1);
1195 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1196 const char *networkId = "softbus";
1197 ret = DlGetRemotePtk(networkId, true, nullptr, STATIC_CAP_LEN + 1);
1198 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1199 }
1200
1201 /*
1202 * @tc.name: LnnSetDLUnifiedDeviceName_Test_001
1203 * @tc.desc: LnnSetDLUnifiedDeviceName
1204 * @tc.type: FUNC
1205 * @tc.require:
1206 */
1207 HWTEST_F(LNNDisctributedLedgerTest, Lnn_Set_DLUnifiedDeviceName_Test_001, TestSize.Level1)
1208 {
1209 char *udid = nullptr;
1210 char *name = nullptr;
1211 int32_t ret = LnnSetDLUnifiedDeviceName(udid, name);
1212 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1213 const char *devUdid = "123456789";
1214 const char *devName = "devicename";
1215 ret = LnnSetDLUnifiedDeviceName(devUdid, devName);
1216 EXPECT_NE(ret, SOFTBUS_OK);
1217 }
1218
1219 /*
1220 * @tc.name: LnnSetDLUnifiedDefaultDeviceName_Test_001
1221 * @tc.desc: LnnSetDLUnifiedDefaultDeviceName
1222 * @tc.type: FUNC
1223 * @tc.require:
1224 */
1225 HWTEST_F(LNNDisctributedLedgerTest, Lnn_Set_DLUnifiedDefaultDeviceName_Test_001, TestSize.Level1)
1226 {
1227 char *udid = nullptr;
1228 char *name = nullptr;
1229 int32_t ret = LnnSetDLUnifiedDefaultDeviceName(udid, name);
1230 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1231 const char *devUdid = "111111111";
1232 const char *devName = "devdefaultdevicename";
1233 ret = LnnSetDLUnifiedDefaultDeviceName(devUdid, devName);
1234 EXPECT_NE(ret, SOFTBUS_OK);
1235 }
1236
1237 /*
1238 * @tc.name: LnnSetDLDeviceNickNameByUdid_Test_001
1239 * @tc.desc: LnnSetDLDeviceNickNameByUdid
1240 * @tc.type: FUNC
1241 * @tc.require:
1242 */
1243 HWTEST_F(LNNDisctributedLedgerTest, Lnn_Set_DLDeviceNickNameByUdid_Test_001, TestSize.Level1)
1244 {
1245 char *udid = nullptr;
1246 char *name = nullptr;
1247 int32_t ret = LnnSetDLDeviceNickNameByUdid(udid, name);
1248 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1249 const char *devUdid = "2222222222";
1250 const char *devName = "deviceNickname";
1251 ret = LnnSetDLDeviceNickNameByUdid(devUdid, devName);
1252 EXPECT_NE(ret, SOFTBUS_OK);
1253 }
1254
1255 /*
1256 * @tc.name: LnnSetDLDeviceStateVersion_Test_001
1257 * @tc.desc: LnnSetDLDeviceStateVersion
1258 * @tc.type: FUNC
1259 * @tc.require:
1260 */
1261 HWTEST_F(LNNDisctributedLedgerTest, Lnn_Set_DLDeviceStateVersion_Test_001, TestSize.Level1)
1262 {
1263 char *udid = nullptr;
1264 int32_t stateVersion = 0;
1265 int32_t ret = LnnSetDLDeviceStateVersion(udid, stateVersion);
1266 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1267 const char *devUdid = "3333333333";
1268 ret = LnnSetDLDeviceStateVersion(devUdid, stateVersion);
1269 EXPECT_NE(ret, SOFTBUS_OK);
1270 }
1271
1272 /*
1273 * @tc.name: LnnSetDLDeviceBroadcastCipherKey_Test_001
1274 * @tc.desc: LnnSetDLDeviceBroadcastCipherKey
1275 * @tc.type: FUNC
1276 * @tc.require:
1277 */
1278 HWTEST_F(LNNDisctributedLedgerTest, Lnn_Set_DLDeviceBroadcastCipherKey_Test_001, TestSize.Level1)
1279 {
1280 char *udid = nullptr;
1281 const char *cipherKey = "qqqqqqqqqqqq";
1282 int32_t ret = LnnSetDLDeviceBroadcastCipherKey(udid, cipherKey);
1283 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1284 const char *devUdid = "123456789";
1285 ret = LnnSetDLDeviceBroadcastCipherKey(devUdid, cipherKey);
1286 EXPECT_NE(ret, SOFTBUS_OK);
1287 }
1288
1289 /*
1290 * @tc.name: LnnSetDLDeviceBroadcastCipherIv_Test_001
1291 * @tc.desc: LnnSetDLDeviceBroadcastCipherIv
1292 * @tc.type: FUNC
1293 * @tc.require:
1294 */
1295 HWTEST_F(LNNDisctributedLedgerTest, Lnn_Set_DLDeviceBroadcastCipherIv_Test_001, TestSize.Level1)
1296 {
1297 char *udid = nullptr;
1298 const char *cipherIv = "qqqqqqqqqqqq";
1299 int32_t ret = LnnSetDLDeviceBroadcastCipherIv(udid, cipherIv);
1300 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1301 const char *devUdid = "123456789";
1302 ret = LnnSetDLDeviceBroadcastCipherIv(devUdid, cipherIv);
1303 EXPECT_NE(ret, SOFTBUS_OK);
1304 }
1305
1306 /*
1307 * @tc.name: LnnUpdateDistributedNodeInfo_Test_001
1308 * @tc.desc: LnnUpdateDistributedNodeInfo
1309 * @tc.type: FUNC
1310 * @tc.require:
1311 */
1312 HWTEST_F(LNNDisctributedLedgerTest, Lnn_UpdateDistributedNodeInfo_Test_001, TestSize.Level1)
1313 {
1314 NodeInfo newInfo;
1315 memset_s(&newInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
1316 const char *udid = nullptr;
1317 newInfo.accountId = 18390933952;
1318 int32_t ret = LnnUpdateDistributedNodeInfo(&newInfo, udid);
1319 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1320 const char *devUdid = "123456789";
1321 ret = LnnUpdateDistributedNodeInfo(&newInfo, devUdid);
1322 EXPECT_EQ(ret, SOFTBUS_OK);
1323 }
1324
1325 /*
1326 * @tc.name: LnnUpdateFileInfo_Test_001
1327 * @tc.desc: UpdateFileInfo
1328 * @tc.type: FUNC
1329 * @tc.require:
1330 */
1331 HWTEST_F(LNNDisctributedLedgerTest, Lnn_UpdateFileInfo_Test_001, TestSize.Level1)
1332 {
1333 NodeInfo newInfo;
1334 memset_s(&newInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
1335 NodeInfo oldInfo;
1336 memset_s(&oldInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
1337 int32_t ret = UpdateFileInfo(&newInfo, &oldInfo);
1338 EXPECT_EQ(ret, SOFTBUS_OK);
1339 (void)memcpy_s(newInfo.cipherInfo.key, SESSION_KEY_LENGTH, "newkey", strlen("newkey"));
1340 (void)memcpy_s(oldInfo.cipherInfo.key, SESSION_KEY_LENGTH, "oldkey", strlen("oldkey"));
1341 ret = UpdateFileInfo(&newInfo, &oldInfo);
1342 EXPECT_EQ(ret, SOFTBUS_OK);
1343
1344 (void)memcpy_s(newInfo.cipherInfo.key, SESSION_KEY_LENGTH, "samekey", strlen("samekey"));
1345 (void)memcpy_s(oldInfo.cipherInfo.key, SESSION_KEY_LENGTH, "samekey", strlen("samekey"));
1346 (void)memcpy_s(newInfo.cipherInfo.iv, SESSION_KEY_LENGTH, "newiv", strlen("newiv"));
1347 (void)memcpy_s(oldInfo.cipherInfo.iv, SESSION_KEY_LENGTH, "oldiv", strlen("oldiv"));
1348 ret = UpdateFileInfo(&newInfo, &oldInfo);
1349 EXPECT_EQ(ret, SOFTBUS_OK);
1350
1351 (void)memcpy_s(newInfo.cipherInfo.iv, SESSION_KEY_LENGTH, "sameiv", strlen("sameiv"));
1352 (void)memcpy_s(oldInfo.cipherInfo.iv, SESSION_KEY_LENGTH, "sameiv", strlen("sameiv"));
1353 (void)memcpy_s(newInfo.rpaInfo.peerIrk, LFINDER_IRK_LEN, "newpeerIrk", strlen("newpeerIrk"));
1354 (void)memcpy_s(oldInfo.rpaInfo.peerIrk, LFINDER_IRK_LEN, "oldIrk", strlen("oldIrk"));
1355 ret = UpdateFileInfo(&newInfo, &oldInfo);
1356 EXPECT_EQ(ret, SOFTBUS_OK);
1357
1358 (void)memcpy_s(newInfo.rpaInfo.peerIrk, LFINDER_IRK_LEN, "sameIrk", strlen("sameIrk"));
1359 (void)memcpy_s(oldInfo.rpaInfo.peerIrk, LFINDER_IRK_LEN, "sameIrk", strlen("sameIrk"));
1360 ret = UpdateFileInfo(&newInfo, &oldInfo);
1361 EXPECT_EQ(ret, SOFTBUS_OK);
1362 }
1363
1364 /*
1365 * @tc.name: Lnn_IsAvailableMeta_Test_001
1366 * @tc.desc: IsAvailableMeta
1367 * @tc.type: FUNC
1368 * @tc.require:
1369 */
1370 HWTEST_F(LNNDisctributedLedgerTest, Lnn_IsAvailableMeta_Test_001, TestSize.Level1)
1371 {
1372 bool ret = IsAvailableMeta(nullptr);
1373 EXPECT_FALSE(ret);
1374 }
1375
1376 /*
1377 * @tc.name: Lnn_IsAvailableMeta_Test_002
1378 * @tc.desc: IsAvailableMeta
1379 * @tc.type: FUNC
1380 * @tc.require:
1381 */
1382 HWTEST_F(LNNDisctributedLedgerTest, Lnn_IsAvailableMeta_Test_002, TestSize.Level1)
1383 {
1384 const char *peerNetworkId = "testNetworkId";
1385 bool ret = IsAvailableMeta(peerNetworkId);
1386 EXPECT_FALSE(ret);
1387 }
1388
1389 /*
1390 * @tc.name: Lnn_IsAvailableMeta_Test_003
1391 * @tc.desc: IsAvailableMeta
1392 * @tc.type: FUNC
1393 * @tc.require:
1394 */
1395 HWTEST_F(LNNDisctributedLedgerTest, Lnn_IsAvailableMeta_Test_003, TestSize.Level1)
1396 {
1397 bool ret = IsAvailableMeta(NODE1_NETWORK_ID);
1398 EXPECT_FALSE(ret);
1399 }
1400
1401 /*
1402 * @tc.name: Lnn_IsAvailableMeta_Test_004
1403 * @tc.desc: IsAvailableMeta
1404 * @tc.type: FUNC
1405 * @tc.require:
1406 */
1407 HWTEST_F(LNNDisctributedLedgerTest, Lnn_IsAvailableMeta_Test_004, TestSize.Level1)
1408 {
1409 LnnEnhanceFuncList *pfnLnnEnhanceFuncList = LnnEnhanceFuncListGet();
1410 pfnLnnEnhanceFuncList->lnnRetrieveDeviceInfo = LnnRetrieveDeviceInfo;
1411
1412 NiceMock<LnnDisctributedNetLedgerInterfaceMock> mock;
1413 EXPECT_CALL(mock, LnnRetrieveDeviceInfo).WillRepeatedly(Return(SOFTBUS_OK));
1414
1415 NodeInfo info;
1416 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
1417 info.discoveryType = DISCOVERY_TYPE;
1418 (void)strncpy_s(info.uuid, UUID_BUF_LEN, NODE2_UUID, strlen(NODE2_UUID));
1419 (void)strncpy_s(info.deviceInfo.deviceUdid, UDID_BUF_LEN, NODE2_UDID, strlen(NODE2_UDID));
1420 (void)strncpy_s(info.networkId, NETWORK_ID_BUF_LEN, NODE2_NETWORK_ID, strlen(NODE2_NETWORK_ID));
1421 (void)strncpy_s(info.connectInfo.macAddr, MAC_LEN, NODE2_BT_MAC, strlen(NODE2_BT_MAC));
1422 info.authSeq[0] = AUTH_SEQ;
1423 info.heartbeatTimestamp = TIME_STAMP;
1424 info.AuthTypeValue = 1 << ONLINE_METANODE;
1425 EXPECT_EQ(REPORT_ONLINE, LnnAddOnlineNode(&info));
1426 bool ret = IsAvailableMeta(NODE2_NETWORK_ID);
1427 EXPECT_TRUE(ret);
1428 }
1429
1430 /*
1431 * @tc.name: Lnn_IsRemoteDeviceSupportBleGuide_Test_001
1432 * @tc.desc: IsRemoteDeviceSupportBleGuide
1433 * @tc.type: FUNC
1434 * @tc.require:
1435 */
1436 HWTEST_F(LNNDisctributedLedgerTest, Lnn_IsRemoteDeviceSupportBleGuide_Test_001, TestSize.Level1)
1437 {
1438 bool ret = IsRemoteDeviceSupportBleGuide(nullptr, CATEGORY_UDID);
1439 EXPECT_TRUE(ret);
1440 }
1441
1442 /*
1443 * @tc.name: Lnn_IsRemoteDeviceSupportBleGuide_Test_002
1444 * @tc.desc: IsRemoteDeviceSupportBleGuide
1445 * @tc.type: FUNC
1446 * @tc.require:
1447 */
1448 HWTEST_F(LNNDisctributedLedgerTest, Lnn_IsRemoteDeviceSupportBleGuide_Test_002, TestSize.Level1)
1449 {
1450 bool ret = IsRemoteDeviceSupportBleGuide("test_id", CATEGORY_UDID);
1451 EXPECT_FALSE(ret);
1452 ret = IsRemoteDeviceSupportBleGuide("test_id", CATEGORY_UUID);
1453 EXPECT_FALSE(ret);
1454 ret = IsRemoteDeviceSupportBleGuide("test_id", CATEGORY_NETWORK_ID);
1455 EXPECT_FALSE(ret);
1456 }
1457
1458 /*
1459 * @tc.name: Lnn_IsRemoteDeviceSupportBleGuide_Test_003
1460 * @tc.desc: IsRemoteDeviceSupportBleGuide
1461 * @tc.type: FUNC
1462 * @tc.require:
1463 */
1464 HWTEST_F(LNNDisctributedLedgerTest, Lnn_IsRemoteDeviceSupportBleGuide_Test_003, TestSize.Level1)
1465 {
1466 bool ret = IsRemoteDeviceSupportBleGuide(NODE1_UDID, CATEGORY_UDID);
1467 EXPECT_TRUE(ret);
1468 ret = IsRemoteDeviceSupportBleGuide(NODE1_UUID, CATEGORY_UUID);
1469 EXPECT_TRUE(ret);
1470 ret = IsRemoteDeviceSupportBleGuide(NODE1_NETWORK_ID, CATEGORY_NETWORK_ID);
1471 EXPECT_TRUE(ret);
1472 ret = IsRemoteDeviceSupportBleGuide(NODE2_UDID, CATEGORY_UDID);
1473 EXPECT_FALSE(ret);
1474 ret = IsRemoteDeviceSupportBleGuide(NODE2_UUID, CATEGORY_UUID);
1475 EXPECT_FALSE(ret);
1476 ret = IsRemoteDeviceSupportBleGuide(NODE2_NETWORK_ID, CATEGORY_NETWORK_ID);
1477 EXPECT_FALSE(ret);
1478 }
1479
1480 /*
1481 * @tc.name: GET_AND_SAVE_REMOTE_DEVICE_INFO_ID_Test_001
1482 * @tc.desc: GetAndSaveRemoteDeviceInfo test
1483 * @tc.type: FUNC
1484 * @tc.require:
1485 */
1486 HWTEST_F(LNNDisctributedLedgerTest, GET_AND_SAVE_REMOTE_DEVICE_INFO_ID_Test_001, TestSize.Level1)
1487 {
1488 NodeInfo deviceInfo;
1489 (void)memset_s(&deviceInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
1490 NodeInfo info;
1491 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
1492 EXPECT_EQ(EOK, strcpy_s(info.deviceInfo.deviceUdid, UDID_BUF_LEN, NODE1_UDID));
1493 EXPECT_EQ(EOK, strcpy_s(info.networkId, NETWORK_ID_BUF_LEN, NODE1_NETWORK_ID));
1494 EXPECT_EQ(EOK, strcpy_s(info.uuid, UUID_BUF_LEN, NODE1_UUID));
1495 EXPECT_EQ(EOK, memcpy_s(info.rpaInfo.peerIrk, LFINDER_IRK_LEN, "newpeerIrk", strlen("newpeerIrk")));
1496 EXPECT_EQ(EOK, memcpy_s(info.cipherInfo.key, SESSION_KEY_LENGTH, "key", strlen("key")));
1497 EXPECT_EQ(EOK, memcpy_s(info.cipherInfo.iv, BROADCAST_IV_LEN, "iv", strlen("iv")));
1498 EXPECT_EQ(EOK, strcpy_s(info.remotePtk, PTK_DEFAULT_LEN, "newPtk"));
1499 EXPECT_EQ(EOK, strcpy_s(deviceInfo.remotePtk, PTK_DEFAULT_LEN, "oldPtk"));
1500 info.netCapacity = 15;
1501 info.accountId = 100;
1502 NiceMock<LnnDisctributedNetLedgerInterfaceMock> mock;
1503 EXPECT_CALL(mock, LnnSaveRemoteDeviceInfo).WillRepeatedly(Return(SOFTBUS_OK));
1504 EXPECT_NO_FATAL_FAILURE(GetAndSaveRemoteDeviceInfo(&deviceInfo, &info));
1505 }
1506
1507 /*
1508 * @tc.name: LNN_UPDATE_NETWORK_ID_Test_001
1509 * @tc.desc: LnnUpdateNetworkId test
1510 * @tc.type: FUNC
1511 * @tc.require:
1512 */
1513 HWTEST_F(LNNDisctributedLedgerTest, LNN_UPDATE_NETWORK_ID_Test_001, TestSize.Level1)
1514 {
1515 NodeInfo info;
1516 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
1517 EXPECT_EQ(EOK, strcpy_s(info.deviceInfo.deviceUdid, UDID_BUF_LEN, NODE1_UDID));
1518 EXPECT_EQ(EOK, strcpy_s(info.networkId, NETWORK_ID_BUF_LEN, NODE2_NETWORK_ID));
1519 EXPECT_EQ(LnnUpdateNetworkId(&info), SOFTBUS_OK);
1520 }
1521
1522 /*
1523 * @tc.name: CHECK_USER_ID_CHECK_SUM_CHANGE_Test_001
1524 * @tc.desc: CheckUserIdCheckSumChange test
1525 * @tc.type: FUNC
1526 * @tc.require:
1527 */
1528 HWTEST_F(LNNDisctributedLedgerTest, CHECK_USER_ID_CHECK_SUM_CHANGE_Test_001, TestSize.Level1)
1529 {
1530 NodeInfo oldInfo;
1531 (void)memset_s(&oldInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
1532 NodeInfo newInfo;
1533 (void)memset_s(&newInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
1534 EXPECT_EQ(EOK, memcpy_s(oldInfo.userIdCheckSum, USERID_CHECKSUM_LEN, "100", strlen("100")));
1535 EXPECT_EQ(EOK, memcpy_s(newInfo.userIdCheckSum, USERID_CHECKSUM_LEN, "100", strlen("100")));
1536 EXPECT_EQ(EOK, strcpy_s(newInfo.networkId, NETWORK_ID_BUF_LEN, NODE2_NETWORK_ID));
1537 newInfo.discoveryType = DISCOVERY_TYPE;
1538 EXPECT_NO_FATAL_FAILURE(CheckUserIdCheckSumChange(nullptr, &newInfo));
1539 EXPECT_NO_FATAL_FAILURE(CheckUserIdCheckSumChange(&oldInfo, nullptr));
1540 EXPECT_NO_FATAL_FAILURE(CheckUserIdCheckSumChange(&oldInfo, &newInfo));
1541 }
1542
1543 /*
1544 * @tc.name: UPDATE_REMOTE_NODE_INFO_Test_001
1545 * @tc.desc: UpdateRemoteNodeInfo test
1546 * @tc.type: FUNC
1547 * @tc.require:
1548 */
1549 HWTEST_F(LNNDisctributedLedgerTest, UPDATE_REMOTE_NODE_INFO_Test_001, TestSize.Level1)
1550 {
1551 NodeInfo oldInfo;
1552 (void)memset_s(&oldInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
1553 EXPECT_EQ(EOK, memcpy_s(oldInfo.userIdCheckSum, USERID_CHECKSUM_LEN, "100", strlen("100")));
1554 oldInfo.discoveryType = DISCOVERY_TYPE;
1555 NodeInfo newInfo;
1556 (void)memset_s(&newInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
1557 EXPECT_EQ(EOK, memcpy_s(newInfo.userIdCheckSum, USERID_CHECKSUM_LEN, "101", strlen("101")));
1558 EXPECT_EQ(EOK, strcpy_s(newInfo.networkId, NETWORK_ID_BUF_LEN, NODE2_NETWORK_ID));
1559 newInfo.discoveryType = DISCOVERY_TYPE;
1560 newInfo.connectInfo.ifInfo[WLAN_IF].authPort = 0;
1561 newInfo.connectInfo.ifInfo[WLAN_IF].proxyPort = 1;
1562 newInfo.connectInfo.ifInfo[WLAN_IF].sessionPort = 3;
1563 EXPECT_EQ(EOK, strcpy_s(newInfo.deviceInfo.deviceName, DEVICE_NAME_BUF_LEN, NODE2_DEVICE_NAME));
1564 EXPECT_EQ(EOK, strcpy_s(newInfo.deviceInfo.nickName, DEVICE_NAME_BUF_LEN, NODE2_DEVICE_NAME));
1565 EXPECT_EQ(EOK, strcpy_s(newInfo.deviceInfo.unifiedName, DEVICE_NAME_BUF_LEN, NODE2_DEVICE_NAME));
1566 EXPECT_EQ(EOK, strcpy_s(newInfo.deviceInfo.unifiedDefaultName, DEVICE_NAME_BUF_LEN, NODE2_DEVICE_NAME));
1567 EXPECT_EQ(EOK, strcpy_s(newInfo.accountHash, SHA_256_HASH_LEN, ACCOUNT_HASH));
1568 newInfo.accountId = 100;
1569 newInfo.userId = 100;
1570 newInfo.localStateVersion = 1;
1571 newInfo.stateVersion = 123;
1572 int32_t connectionType = CONNECTION_ADDR_BLE;
1573 EXPECT_EQ(SOFTBUS_INVALID_PARAM, UpdateRemoteNodeInfo(nullptr, &newInfo, connectionType, nullptr));
1574 EXPECT_EQ(SOFTBUS_INVALID_PARAM, UpdateRemoteNodeInfo(&oldInfo, nullptr, connectionType, nullptr));
1575 EXPECT_EQ(SOFTBUS_OK, UpdateRemoteNodeInfo(&oldInfo, &newInfo, connectionType, nullptr));
1576 }
1577
1578 /*
1579 * @tc.name: ONLINE_PREVENT_BR_CONNECTION_Test_001
1580 * @tc.desc: OnlinePreventBrConnection test
1581 * @tc.type: FUNC
1582 * @tc.require:
1583 */
1584 HWTEST_F(LNNDisctributedLedgerTest, ONLINE_PREVENT_BR_CONNECTION_Test_001, TestSize.Level1)
1585 {
1586 NodeInfo info;
1587 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
1588 EXPECT_EQ(EOK, strcpy_s(info.networkId, NETWORK_ID_BUF_LEN, NODE1_NETWORK_ID));
1589 EXPECT_EQ(EOK, strcpy_s(info.connectInfo.macAddr, MAC_LEN, NODE1_BT_MAC));
1590 EXPECT_EQ(EOK, strcpy_s(info.softBusVersion, VERSION_MAX_LEN, SOFTBUS_VERSION));
1591 info.bleStartTimestamp = TIME_STAMP;
1592 EXPECT_NO_FATAL_FAILURE(OnlinePreventBrConnection(&info));
1593 }
1594
1595 /*
1596 * @tc.name: LNN_UPDATE_ACCOUNT_INFO_Test_001
1597 * @tc.desc: LnnUpdateAccountInfo test
1598 * @tc.type: FUNC
1599 * @tc.require:
1600 */
1601 HWTEST_F(LNNDisctributedLedgerTest, LNN_UPDATE_ACCOUNT_INFO_Test_001, TestSize.Level1)
1602 {
1603 NodeInfo info;
1604 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
1605 EXPECT_EQ(EOK, strcpy_s(info.deviceInfo.deviceUdid, UDID_BUF_LEN, NODE1_UDID));
1606 info.accountId = 100;
1607 info.userId = 100;
1608 EXPECT_EQ(SOFTBUS_OK, LnnUpdateAccountInfo(&info));
1609 }
1610
1611 /*
1612 * @tc.name: LNN_UPDATE_REMOTE_DEVICE_NAME_Test_001
1613 * @tc.desc: LnnUpdateRemoteDeviceName test
1614 * @tc.type: FUNC
1615 * @tc.require:
1616 */
1617 HWTEST_F(LNNDisctributedLedgerTest, LNN_UPDATE_REMOTE_DEVICE_NAME_Test_001, TestSize.Level1)
1618 {
1619 NodeInfo info;
1620 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
1621 EXPECT_EQ(EOK, strcpy_s(info.deviceInfo.deviceUdid, UDID_BUF_LEN, NODE1_UDID));
1622 EXPECT_EQ(EOK, strcpy_s(info.deviceInfo.deviceName, DEVICE_NAME_BUF_LEN, NODE2_DEVICE_NAME));
1623 EXPECT_EQ(SOFTBUS_INVALID_PARAM, LnnUpdateRemoteDeviceName(nullptr));
1624 EXPECT_EQ(SOFTBUS_OK, LnnUpdateRemoteDeviceName(&info));
1625 EXPECT_EQ(EOK, strcpy_s(info.deviceInfo.deviceName, DEVICE_NAME_BUF_LEN, NODE1_DEVICE_NAME));
1626 EXPECT_EQ(SOFTBUS_OK, LnnUpdateRemoteDeviceName(&info));
1627 EXPECT_EQ(EOK, strcpy_s(info.deviceInfo.deviceUdid, UDID_BUF_LEN, NODE3_UDID));
1628 EXPECT_EQ(SOFTBUS_OK, LnnUpdateRemoteDeviceName(&info));
1629 }
1630
1631 /*
1632 * @tc.name: CLEAR_AUTH_CHANNEL_ID_Test_001
1633 * @tc.desc: ClearAuthChannelId test
1634 * @tc.type: FUNC
1635 * @tc.require:
1636 */
1637 HWTEST_F(LNNDisctributedLedgerTest, CLEAR_AUTH_CHANNEL_ID_Test_001, TestSize.Level1)
1638 {
1639 NodeInfo info;
1640 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
1641 info.discoveryType = 4;
1642 info.authChannelId[CONNECTION_ADDR_BLE][AUTH_AS_CLIENT_SIDE] = AUTH_ID;
1643 info.authChannelId[CONNECTION_ADDR_BLE][AUTH_AS_CLIENT_SIDE] = AUTH_ID;
1644 EXPECT_EQ(REPORT_OFFLINE, ClearAuthChannelId(&info, CONNECTION_ADDR_BLE, AUTH_ID));
1645 EXPECT_EQ(REPORT_OFFLINE, ClearAuthChannelId(&info, CONNECTION_ADDR_BLE, 0));
1646 info.discoveryType = 8;
1647 EXPECT_EQ(REPORT_OFFLINE, ClearAuthChannelId(&info, CONNECTION_ADDR_BLE, 0));
1648 }
1649
1650 /*
1651 * @tc.name: LNN_CONVERT_DL_ID_Test_001
1652 * @tc.desc: LnnConvertDlId test
1653 * @tc.type: FUNC
1654 * @tc.require:
1655 */
1656 HWTEST_F(LNNDisctributedLedgerTest, LNN_CONVERT_DL_ID_Test_001, TestSize.Level1)
1657 {
1658 const char *srcId = "123456ABCDEF";
1659 char dstIdBuf[UDID_BUF_LEN] = { 0 };
1660 EXPECT_EQ(SOFTBUS_OK, LnnConvertDlId(const_cast<char *>(srcId), CATEGORY_UDID,
1661 CATEGORY_UDID, dstIdBuf, UDID_BUF_LEN));
1662 const char *srcId1 = "123456ABCDEFGHI";
1663 char dstIdBuf1[UUID_BUF_LEN] = { 0 };
1664 EXPECT_EQ(SOFTBUS_NOT_FIND, LnnConvertDlId(const_cast<char *>(srcId1), CATEGORY_UUID,
1665 CATEGORY_UUID, dstIdBuf1, UUID_BUF_LEN));
1666 const char *srcId2 = "235689BNHFCF";
1667 char dstIdBuf2[NETWORK_ID_BUF_LEN] = { 0 };
1668 EXPECT_EQ(SOFTBUS_OK, LnnConvertDlId(const_cast<char *>(srcId2), CATEGORY_NETWORK_ID,
1669 CATEGORY_NETWORK_ID, dstIdBuf2, NETWORK_ID_BUF_LEN));
1670 EXPECT_EQ(SOFTBUS_INVALID_PARAM, LnnConvertDlId(nullptr, CATEGORY_UDID, CATEGORY_UDID, dstIdBuf, UDID_BUF_LEN));
1671 EXPECT_EQ(SOFTBUS_NOT_FIND, LnnConvertDlId(const_cast<char *>(srcId2), CATEGORY_UDID,
1672 CATEGORY_UDID, dstIdBuf, UDID_BUF_LEN));
1673 }
1674
1675 /*
1676 * @tc.name: UPDATE_DEVICE_NAME_TO_DLEDGER_Test_001
1677 * @tc.desc: UpdateDeviceNameToDLedger test
1678 * @tc.type: FUNC
1679 * @tc.require:
1680 */
1681 HWTEST_F(LNNDisctributedLedgerTest, UPDATE_DEVICE_NAME_TO_DLEDGER_Test_001, TestSize.Level1)
1682 {
1683 NodeInfo newInfo;
1684 (void)memset_s(&newInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
1685 NodeInfo oldInfo;
1686 (void)memset_s(&oldInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
1687 EXPECT_NO_FATAL_FAILURE(UpdateDeviceNameToDLedger(&newInfo, &oldInfo));
1688 EXPECT_EQ(EOK, strcpy_s(newInfo.deviceInfo.deviceName, DEVICE_NAME_BUF_LEN, NODE2_DEVICE_NAME));
1689 EXPECT_EQ(EOK, strcpy_s(newInfo.deviceInfo.nickName, DEVICE_NAME_BUF_LEN, NODE2_DEVICE_NAME));
1690 EXPECT_EQ(EOK, strcpy_s(newInfo.deviceInfo.unifiedName, DEVICE_NAME_BUF_LEN, NODE2_DEVICE_NAME));
1691 EXPECT_EQ(EOK, strcpy_s(newInfo.deviceInfo.unifiedDefaultName, DEVICE_NAME_BUF_LEN, NODE2_DEVICE_NAME));
1692 EXPECT_NO_FATAL_FAILURE(UpdateDeviceNameToDLedger(&newInfo, &oldInfo));
1693 }
1694
1695 /*
1696 * @tc.name: UPDATE_DEV_BASIC_INFO_TO_DLEDGER_Test_001
1697 * @tc.desc: UpdateDevBasicInfoToDLedger test
1698 * @tc.type: FUNC
1699 * @tc.require:
1700 */
1701 HWTEST_F(LNNDisctributedLedgerTest, UPDATE_DEV_BASIC_INFO_TO_DLEDGER_Test_001, TestSize.Level1)
1702 {
1703 NiceMock<LnnDisctributedNetLedgerInterfaceMock> mock;
1704 NodeInfo newInfo;
1705 (void)memset_s(&newInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
1706 EXPECT_EQ(EOK, strcpy_s(newInfo.networkId, NETWORK_ID_BUF_LEN, NODE1_NETWORK_ID));
1707 EXPECT_EQ(EOK, strcpy_s(newInfo.deviceInfo.deviceUdid, UDID_BUF_LEN, NODE1_UDID));
1708 EXPECT_EQ(EOK, strcpy_s(newInfo.deviceInfo.deviceVersion, DEVICE_VERSION_SIZE_MAX, SOFTBUS_VERSION));
1709 NodeInfo oldInfo;
1710 (void)memset_s(&oldInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
1711 EXPECT_EQ(EOK, strcpy_s(oldInfo.networkId, NETWORK_ID_BUF_LEN, NODE1_NETWORK_ID));
1712 oldInfo.status = STATUS_OFFLINE;
1713 EXPECT_NO_FATAL_FAILURE(UpdateDevBasicInfoToDLedger(&newInfo, &oldInfo));
1714 EXPECT_EQ(EOK, strcpy_s(oldInfo.networkId, NETWORK_ID_BUF_LEN, NODE2_NETWORK_ID));
1715 EXPECT_NO_FATAL_FAILURE(UpdateDevBasicInfoToDLedger(&newInfo, &oldInfo));
1716 oldInfo.status = STATUS_ONLINE;
1717 oldInfo.discoveryType = 2;
1718 EXPECT_NO_FATAL_FAILURE(UpdateDevBasicInfoToDLedger(&newInfo, &oldInfo));
1719 oldInfo.discoveryType = 4;
1720 EXPECT_NO_FATAL_FAILURE(UpdateDevBasicInfoToDLedger(&newInfo, &oldInfo));
1721 EXPECT_CALL(mock, LnnFindDeviceUdidTrustedInfoFromDb).WillRepeatedly(Return(SOFTBUS_NOT_FIND));
1722 EXPECT_NO_FATAL_FAILURE(UpdateDevBasicInfoToDLedger(&newInfo, &oldInfo));
1723 EXPECT_CALL(mock, LnnFindDeviceUdidTrustedInfoFromDb).WillRepeatedly(Return(SOFTBUS_OK));
1724 EXPECT_NO_FATAL_FAILURE(UpdateDevBasicInfoToDLedger(&newInfo, &oldInfo));
1725 }
1726
1727 /*
1728 * @tc.name: UPDATE_DISTRIBUTED_LEDGER_Test_001
1729 * @tc.desc: UpdateDistributedLedger test
1730 * @tc.type: FUNC
1731 * @tc.require:
1732 */
1733 HWTEST_F(LNNDisctributedLedgerTest, UPDATE_DISTRIBUTED_LEDGER_Test_001, TestSize.Level1)
1734 {
1735 NodeInfo newInfo;
1736 (void)memset_s(&newInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
1737 NodeInfo oldInfo;
1738 (void)memset_s(&oldInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
1739 EXPECT_NO_FATAL_FAILURE(UpdateDistributedLedger(nullptr, &oldInfo));
1740 EXPECT_NO_FATAL_FAILURE(UpdateDistributedLedger(&newInfo, nullptr));
1741 EXPECT_EQ(EOK, strcpy_s(newInfo.networkId, NETWORK_ID_BUF_LEN, NODE1_NETWORK_ID));
1742 EXPECT_EQ(EOK, strcpy_s(newInfo.softBusVersion, VERSION_MAX_LEN, SOFTBUS_VERSION));
1743 EXPECT_EQ(EOK, strcpy_s(newInfo.connectInfo.macAddr, MAC_LEN, NODE1_BT_MAC));
1744 EXPECT_EQ(EOK, strcpy_s(newInfo.deviceInfo.osVersion, OS_VERSION_BUF_LEN, SOFTBUS_VERSION));
1745 EXPECT_EQ(EOK, strcpy_s(newInfo.p2pInfo.p2pMac, MAC_LEN, P2P_MAC));
1746 EXPECT_EQ(EOK, memcpy_s(newInfo.rpaInfo.peerIrk, LFINDER_IRK_LEN, "newpeerIrk", strlen("newpeerIrk")));
1747 EXPECT_EQ(EOK, memcpy_s(newInfo.rpaInfo.publicAddress, LFINDER_MAC_ADDR_LEN, "12345", strlen("12345")));
1748 EXPECT_EQ(EOK, memcpy_s(newInfo.cipherInfo.key, SESSION_KEY_LENGTH, "samekey", strlen("samekey")));
1749 EXPECT_EQ(EOK, memcpy_s(newInfo.cipherInfo.iv, BROADCAST_IV_LEN, "samekeyIv", strlen("samekeyIv")));
1750 EXPECT_EQ(EOK, strcpy_s(oldInfo.networkId, NETWORK_ID_BUF_LEN, NODE1_NETWORK_ID));
1751 EXPECT_NO_FATAL_FAILURE(UpdateDistributedLedger(&newInfo, &oldInfo));
1752 }
1753
1754 /*
1755 * @tc.name: IS_IGNORE_UPDATE_TO_LEDGER_Test_001
1756 * @tc.desc: IsIgnoreUpdateToLedger test
1757 * @tc.type: FUNC
1758 * @tc.require:
1759 */
1760 HWTEST_F(LNNDisctributedLedgerTest, IS_IGNORE_UPDATE_TO_LEDGER_Test_001, TestSize.Level1)
1761 {
1762 int32_t oldStateVersion = 0;
1763 uint64_t oldTimestamp = 1;
1764 int32_t newStateVersion = 0;
1765 uint64_t newTimestamp = 0;
1766 EXPECT_EQ(true, IsIgnoreUpdateToLedger(oldStateVersion, oldTimestamp, newStateVersion, newTimestamp));
1767 newTimestamp = 1;
1768 EXPECT_EQ(false, IsIgnoreUpdateToLedger(oldStateVersion, oldTimestamp, newStateVersion, newTimestamp));
1769 }
1770 } // namespace OHOS
1771