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