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 "lnn_distributed_net_ledger.h"
17
18 #include <gtest/gtest.h>
19 #include <securec.h>
20 #include <cstddef>
21 #include <cstdlib>
22 #include <cstring>
23
24 #include "lnn_connection_addr_utils.h"
25 #include "lnn_fast_offline.h"
26 #include "lnn_map.h"
27 #include "lnn_node_info.h"
28 #include "softbus_adapter_mem.h"
29 #include "softbus_adapter_thread.h"
30 #include "softbus_bus_center.h"
31 #include "softbus_errcode.h"
32 #include "softbus_log.h"
33 #include "softbus_utils.h"
34 #include "softbus_hidumper_buscenter.h"
35 #include "bus_center_manager.h"
36
37 namespace OHOS {
38 using namespace testing::ext;
39 constexpr char NODE1_DEVICE_NAME[] = "node1_test";
40 constexpr char NODE1_UDID[] = "123456ABCDEF";
41 constexpr char NODE1_NETWORK_ID[] = "235689BNHFCF";
42 constexpr char NODE1_UUID[] = "235689BNHFCC";
43 constexpr char NODE1_BT_MAC[] = "56789TTU";
44 constexpr char NODE2_DEVICE_NAME[] = "node2_test";
45 constexpr char NODE2_UDID[] = "123456ABCDEG";
46 constexpr char NODE2_NETWORK_ID[] = "235689BNHFCG";
47 constexpr char NODE2_UUID[] = "235689BNHFCD";
48 constexpr char NODE2_BT_MAC[] = "56789TYU";
49 constexpr char P2P_MAC[] = "11:22:33:44:55";
50 constexpr char GO_MAC[] = "22:33:44:55:66";
51 constexpr int32_t P2P_ROLE = 1;
52 constexpr uint32_t DISCOVERY_TYPE = 62;
53 constexpr int32_t AUTH_ID = 10;
54 constexpr uint64_t TIME_STAMP = 5000;
55 constexpr uint64_t CAPABILITY = 62;
56 constexpr uint64_t NEW_TIME_STAMP = 6000;
57 constexpr int64_t AUTH_SEQ = 1;
58 constexpr char NODE_ADDRESS[] = "address";
59 constexpr char RECV_UDID_HASH[] = "87654321";
60 constexpr int32_t INVALID_LANE_ID = -1;
61 using namespace testing;
62 class DisctributedLedgerTest : public testing::Test {
63 public:
64 static void SetUpTestCase();
65 static void TearDownTestCase();
66 void SetUp();
67 void TearDown();
68 };
69
SetUpTestCase()70 void DisctributedLedgerTest::SetUpTestCase()
71 {
72 }
73
TearDownTestCase()74 void DisctributedLedgerTest::TearDownTestCase()
75 {
76 }
77
SetUp()78 void DisctributedLedgerTest::SetUp()
79 {
80 LOG_INFO("LocalLedgerTest start.");
81 int32_t ret = LnnInitDistributedLedger();
82 EXPECT_TRUE(ret == SOFTBUS_OK);
83 NodeInfo info;
84 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
85 info.discoveryType = DISCOVERY_TYPE;
86 (void)strcpy_s(info.uuid, UUID_BUF_LEN, NODE1_UUID);
87 (void)strcpy_s(info.deviceInfo.deviceUdid, UDID_BUF_LEN, NODE1_UDID);
88 (void)strcpy_s(info.networkId, NETWORK_ID_BUF_LEN, NODE1_NETWORK_ID);
89 (void)strcpy_s(info.connectInfo.macAddr, MAC_LEN, NODE1_BT_MAC);
90 info.authSeq[0] = AUTH_SEQ;
91 info.heartbeatTimeStamp = TIME_STAMP;
92 EXPECT_TRUE(REPORT_ONLINE == LnnAddOnlineNode(&info));
93 }
94
TearDown()95 void DisctributedLedgerTest::TearDown()
96 {
97 LOG_INFO("LocalLedgerTest end.");
98 LnnDeinitDistributedLedger();
99 }
100
101 /*
102 * @tc.name: LNN_ADD_ONLINE_NODE_Test_001
103 * @tc.desc: lnn add online node test
104 * @tc.type: FUNC
105 * @tc.require:
106 */
107 HWTEST_F(DisctributedLedgerTest, LNN_ADD_ONLINE_NODE_Test_001, TestSize.Level1)
108 {
109 NodeInfo info;
110 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
111 info.discoveryType = DISCOVERY_TYPE;
112 (void)strcpy_s(info.uuid, UUID_BUF_LEN, NODE1_UUID);
113 (void)strcpy_s(info.deviceInfo.deviceUdid, UDID_BUF_LEN, NODE1_UDID);
114 (void)strcpy_s(info.networkId, NETWORK_ID_BUF_LEN, NODE1_NETWORK_ID);
115 (void)strcpy_s(info.connectInfo.macAddr, MAC_LEN, NODE1_BT_MAC);
116 EXPECT_TRUE(REPORT_NONE == LnnAddOnlineNode(&info));
117 }
118
119 /*
120 * @tc.name: LNN_GET_REMOTE_STRINFO_Test_001
121 * @tc.desc: lnn get remote strInfo test
122 * @tc.type: FUNC
123 * @tc.require:
124 */
125 HWTEST_F(DisctributedLedgerTest, LNN_GET_REMOTE_STRINFO_Test_001, TestSize.Level1)
126 {
127 static InfoKey keyStringTable[] = {
128 STRING_KEY_HICE_VERSION,
129 STRING_KEY_DEV_UDID,
130 STRING_KEY_UUID,
131 STRING_KEY_DEV_TYPE,
132 STRING_KEY_DEV_NAME,
133 STRING_KEY_BT_MAC,
134 STRING_KEY_WLAN_IP,
135 STRING_KEY_MASTER_NODE_UDID,
136 STRING_KEY_P2P_MAC,
137 STRING_KEY_P2P_GO_MAC,
138 STRING_KEY_NODE_ADDR,
139 STRING_KEY_OFFLINE_CODE
140 };
141 char buf[UDID_BUF_LEN] = {0};
142 int32_t ret = LnnGetRemoteStrInfo(nullptr, STRING_KEY_HICE_VERSION, buf, UDID_BUF_LEN);
143 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
144 ret = LnnGetRemoteStrInfo(NODE1_NETWORK_ID, STRING_KEY_HICE_VERSION, nullptr, UDID_BUF_LEN);
145 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
146 ret = LnnGetRemoteStrInfo(NODE1_NETWORK_ID, NUM_KEY_BEGIN, buf, UDID_BUF_LEN);
147 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
148 uint32_t i;
149 for (i = 0; i < sizeof(keyStringTable) / sizeof(InfoKey); i++) {
150 (void)memset_s(buf, UDID_BUF_LEN, 0, UDID_BUF_LEN);
151 ret = LnnGetRemoteStrInfo(NODE1_NETWORK_ID, keyStringTable[i], buf, UDID_BUF_LEN);
152 EXPECT_TRUE(ret == SOFTBUS_OK);
153 }
154 for (i = 0; i < sizeof(keyStringTable) / sizeof(InfoKey); i++) {
155 ret = LnnGetRemoteStrInfo(NODE2_NETWORK_ID, keyStringTable[i], buf, UDID_BUF_LEN);
156 EXPECT_TRUE(ret == SOFTBUS_ERR);
157 }
158 }
159
160 /*
161 * @tc.name: LNN_GET_REMOTE_NUMNFO_Test_002
162 * @tc.desc: lnn get remote num info test
163 * @tc.type: FUNC
164 * @tc.require:
165 */
166 HWTEST_F(DisctributedLedgerTest, LNN_GET_REMOTE_NUMNFO_Test_002, TestSize.Level1)
167 {
168 static InfoKey keyNumTable[] = {
169 NUM_KEY_META_NODE,
170 NUM_KEY_SESSION_PORT,
171 NUM_KEY_AUTH_PORT,
172 NUM_KEY_PROXY_PORT,
173 NUM_KEY_NET_CAP,
174 NUM_KEY_DISCOVERY_TYPE,
175 NUM_KEY_MASTER_NODE_WEIGHT,
176 NUM_KEY_P2P_ROLE
177 };
178 int32_t ret;
179 uint32_t i;
180 int32_t len = LNN_COMMON_LEN;
181 for (i = 0; i < sizeof(keyNumTable) / sizeof(InfoKey); i++) {
182 ret = LnnGetRemoteNumInfo(NODE1_NETWORK_ID, keyNumTable[i], &len);
183 EXPECT_TRUE(ret == SOFTBUS_OK);
184 }
185 for (i = 0; i < sizeof(keyNumTable) / sizeof(InfoKey); i++) {
186 ret = LnnGetRemoteNumInfo(NODE2_NETWORK_ID, keyNumTable[i], &len);
187 EXPECT_TRUE(ret == SOFTBUS_ERR);
188 }
189 }
190
191 /*
192 * @tc.name: LNN_GET_CNN_CODE_Test_001
193 * @tc.desc: lnn get cnn code test
194 * @tc.type: FUNC
195 * @tc.require:
196 */
197 HWTEST_F(DisctributedLedgerTest, LNN_GET_CNN_CODE_Test_001, TestSize.Level1)
198 {
199 DiscoveryType type = DISCOVERY_TYPE_WIFI;
200 short ret = LnnGetCnnCode(nullptr, type);
201 EXPECT_TRUE(ret == INVALID_CONNECTION_CODE_VALUE);
202 ret = LnnGetCnnCode(NODE1_UUID, type);
203 EXPECT_TRUE(ret == INVALID_CONNECTION_CODE_VALUE);
204 ret = LnnGetCnnCode(NODE2_UUID, type);
205 EXPECT_TRUE(ret == INVALID_CONNECTION_CODE_VALUE);
206 }
207
208 /*
209 * @tc.name: LNN_UPDATE_NODE_INFO_Test_001
210 * @tc.desc: lnn update node info test
211 * @tc.type: FUNC
212 * @tc.require:
213 */
214 HWTEST_F(DisctributedLedgerTest, LNN_UPDATE_NODE_INFO_Test_001, TestSize.Level1)
215 {
216 NodeInfo newInfo;
217 (void)memset_s(&newInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
218 (void)strcpy_s(newInfo.deviceInfo.deviceUdid, UDID_BUF_LEN, NODE1_UDID);
219 int32_t ret = LnnUpdateNodeInfo(&newInfo);
220 EXPECT_TRUE(ret == SOFTBUS_OK);
221 (void)memset_s(&newInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
222 (void)strcpy_s(newInfo.deviceInfo.deviceUdid, UDID_BUF_LEN, NODE2_UDID);
223 ret = LnnUpdateNodeInfo(&newInfo);
224 EXPECT_TRUE(ret == SOFTBUS_ERR);
225 }
226
227 /*
228 * @tc.name: LNN_SET_NODE_OFFLINE_Test_001
229 * @tc.desc: lnn set node offline test
230 * @tc.type: FUNC
231 * @tc.require:
232 */
233 HWTEST_F(DisctributedLedgerTest, LNN_SET_NODE_OFFLINE_Test_001, TestSize.Level1)
234 {
235 EXPECT_TRUE(REPORT_NONE == LnnSetNodeOffline(NODE1_UUID, CONNECTION_ADDR_WLAN, AUTH_ID));
236 EXPECT_TRUE(REPORT_NONE == LnnSetNodeOffline(NODE2_UUID, CONNECTION_ADDR_WLAN, AUTH_ID));
237 }
238
239 /*
240 * @tc.name: LNN_GET_BASIC_INFO_BY_UDID_Test_001
241 * @tc.desc: lnn get basic info by udid test
242 * @tc.type: FUNC
243 * @tc.require:
244 */
245 HWTEST_F(DisctributedLedgerTest, LNN_GET_BASIC_INFO_BY_UDID_Test_001, TestSize.Level1)
246 {
247 NodeBasicInfo basicInfo;
248 (void)memset_s(&basicInfo, sizeof(NodeBasicInfo), 0, sizeof(NodeBasicInfo));
249 int32_t ret = LnnGetBasicInfoByUdid(NODE1_UDID, nullptr);
250 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
251 ret = LnnGetBasicInfoByUdid(NODE1_UDID, &basicInfo);
252 EXPECT_TRUE(ret == SOFTBUS_OK);
253 }
254
255 /*
256 * @tc.name: LNN_CONVERT_DLID_Test_001
257 * @tc.desc: lnn convert dl id test
258 * @tc.type: FUNC
259 * @tc.require:
260 */
261
262 HWTEST_F(DisctributedLedgerTest, LNN_CONVERT_DLID_Test_001, TestSize.Level1)
263 {
264 char buf[UDID_BUF_LEN] = {0};
265 int32_t ret = LnnConvertDlId(nullptr, CATEGORY_UDID, CATEGORY_UDID, buf, UDID_BUF_LEN);
266 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
267 ret = LnnConvertDlId(NODE1_UDID, CATEGORY_UDID, CATEGORY_UDID, buf, UDID_BUF_LEN);
268 EXPECT_TRUE(ret == SOFTBUS_OK);
269 ret = LnnConvertDlId(NODE2_UDID, CATEGORY_UDID, CATEGORY_UDID, buf, UDID_BUF_LEN);
270 EXPECT_TRUE(ret == SOFTBUS_NOT_FIND);
271 ret = LnnConvertDlId(NODE2_UUID, CATEGORY_UUID, CATEGORY_UUID, buf, UDID_BUF_LEN);
272 EXPECT_TRUE(ret == SOFTBUS_NOT_FIND);
273 ret = LnnConvertDlId(NODE2_NETWORK_ID, CATEGORY_NETWORK_ID, CATEGORY_NETWORK_ID, buf, NETWORK_ID_BUF_LEN);
274 EXPECT_TRUE(ret == SOFTBUS_NOT_FIND);
275 }
276
277 /*
278 * @tc.name: LNN_SET_DLP2P_INFO_Test_001
279 * @tc.desc: lnn get lnn relation test
280 * @tc.type: FUNC
281 * @tc.require:
282 */
283 HWTEST_F(DisctributedLedgerTest, LNN_SET_DLP2P_INFO_Test_001, TestSize.Level1)
284 {
285 P2pInfo info;
286 (void)memset_s(&info, sizeof(P2pInfo), 0, sizeof(P2pInfo));
287 (void)strcpy_s(info.p2pMac, MAC_LEN, P2P_MAC);
288 (void)strcpy_s(info.goMac, MAC_LEN, GO_MAC);
289 info.p2pRole = P2P_ROLE;
290 bool ret = LnnSetDLP2pInfo(nullptr, &info);
291 EXPECT_TRUE(ret == false);
292 ret = LnnSetDLP2pInfo(NODE1_NETWORK_ID, &info);
293 EXPECT_TRUE(ret == true);
294 ret = LnnSetDLP2pInfo(NODE2_NETWORK_ID, &info);
295 EXPECT_TRUE(ret == false);
296 }
297
298 /*
299 * @tc.name: LNN_GET_NETWORKID_BYBTMAC_Test_001
300 * @tc.desc: lnn get neteorkId by bt mac test
301 * @tc.type: FUNC
302 * @tc.require:
303 */
304 HWTEST_F(DisctributedLedgerTest, LNN_GET_NETWORKID_BYBTMAC_Test_001, TestSize.Level1)
305 {
306 char buf[NETWORK_ID_BUF_LEN] = {0};
307 int32_t ret = LnnGetNetworkIdByBtMac(nullptr, buf, NETWORK_ID_BUF_LEN);
308 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
309 ret = LnnGetNetworkIdByBtMac(NODE1_BT_MAC, buf, NETWORK_ID_BUF_LEN);
310 EXPECT_TRUE(ret == SOFTBUS_OK);
311 ret = LnnGetNetworkIdByBtMac(NODE2_BT_MAC, buf, NETWORK_ID_BUF_LEN);
312 EXPECT_TRUE(ret == SOFTBUS_ERR);
313 }
314
315 /*
316 * @tc.name: LNN_GET_NETWORKID_BY_UUID_Test_001
317 * @tc.desc: lnn get neteorkId by uuid test
318 * @tc.type: FUNC
319 * @tc.require:
320 */
321 HWTEST_F(DisctributedLedgerTest, LNN_GET_NETWORKID_BY_UUID_Test_001, TestSize.Level1)
322 {
323 char buf[UUID_BUF_LEN] = {0};
324 int32_t ret = LnnGetNetworkIdByUuid(nullptr, buf, UUID_BUF_LEN);
325 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
326 ret = LnnGetNetworkIdByUuid(NODE1_UUID, buf, NETWORK_ID_BUF_LEN);
327 EXPECT_TRUE(ret == SOFTBUS_OK);
328 ret = LnnGetNetworkIdByUuid(NODE2_UUID, buf, NETWORK_ID_BUF_LEN);
329 EXPECT_TRUE(ret == SOFTBUS_ERR);
330 }
331
332 /*
333 * @tc.name: LNN_GET_NETWORKID_BY_UDID_Test_001
334 * @tc.desc: lnn get neteorkId by udid test
335 * @tc.type: FUNC
336 * @tc.require:
337 */
338 HWTEST_F(DisctributedLedgerTest, LNN_GET_NETWORKID_BY_UDID_Test_001, TestSize.Level1)
339 {
340 char buf[UDID_BUF_LEN] = {0};
341 int32_t ret = LnnGetNetworkIdByUdid(nullptr, buf, UDID_BUF_LEN);
342 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
343 ret = LnnGetNetworkIdByUdid(NODE1_UDID, buf, UDID_BUF_LEN);
344 EXPECT_TRUE(ret == SOFTBUS_OK);
345 ret = LnnGetNetworkIdByUdid(NODE2_UDID, buf, UDID_BUF_LEN);
346 EXPECT_TRUE(ret == SOFTBUS_ERR);
347 }
348
349 /*
350 * @tc.name: LNN_GET_ALL_AUTH_SEQ_Test_001
351 * @tc.desc: lnn get all auth seq test
352 * @tc.type: FUNC
353 * @tc.require:
354 */
355 HWTEST_F(DisctributedLedgerTest, LNN_GET_ALL_AUTH_SEQ_Test_001, TestSize.Level1)
356 {
357 int64_t authSeq[DISCOVERY_TYPE_COUNT] = {0};
358 int32_t ret = LnnGetAllAuthSeq(nullptr, authSeq, DISCOVERY_TYPE_COUNT);
359 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
360 ret = LnnGetAllAuthSeq(NODE1_UDID, authSeq, DISCOVERY_TYPE_COUNT);
361 EXPECT_TRUE(ret == SOFTBUS_OK);
362 ret = LnnGetAllAuthSeq(NODE2_UDID, authSeq, DISCOVERY_TYPE_COUNT);
363 EXPECT_TRUE(ret == SOFTBUS_ERR);
364 }
365
366 /*
367 * @tc.name: LNN_GET_DLHEARTBEAT_TIMER_STAMP_Test_001
368 * @tc.desc: lnn get dl heartbeat time stamp test
369 * @tc.type: FUNC
370 * @tc.require:
371 */
372 HWTEST_F(DisctributedLedgerTest, LNN_GET_DLHEARTBEAT_TIMER_STAMP_Test_001, TestSize.Level1)
373 {
374 uint64_t timeStamp;
375 int32_t ret = LnnGetDLHeartbeatTimestamp(NODE1_NETWORK_ID, &timeStamp);
376 EXPECT_TRUE(ret == SOFTBUS_OK);
377 ret = LnnGetDLHeartbeatTimestamp(NODE2_NETWORK_ID, &timeStamp);
378 EXPECT_TRUE(ret == SOFTBUS_ERR);
379 }
380
381 /*
382 * @tc.name: LNN_SET_DLHEARTBEAT_TIMER_STAMP_Test_001
383 * @tc.desc: lnn set dl heartbeat time stamp test
384 * @tc.type: FUNC
385 * @tc.require:
386 */
387 HWTEST_F(DisctributedLedgerTest, LNN_SET_DLHEARTBEAT_TIMER_STAMP_Test_001, TestSize.Level1)
388 {
389 uint64_t timeStamp = NEW_TIME_STAMP;
390 int32_t ret = LnnSetDLHeartbeatTimestamp(NODE1_NETWORK_ID, timeStamp);
391 EXPECT_TRUE(ret == SOFTBUS_OK);
392 ret = LnnSetDLHeartbeatTimestamp(NODE2_NETWORK_ID, timeStamp);
393 EXPECT_TRUE(ret == SOFTBUS_ERR);
394 }
395
396 /*
397 * @tc.name: LNN_SET_DLCONN_CAPABILITY_Test_001
398 * @tc.desc: lnn set dl conn capability test
399 * @tc.type: FUNC
400 * @tc.require:
401 */
402 HWTEST_F(DisctributedLedgerTest, LNN_SET_DLCONN_CAPABILITY_Test_001, TestSize.Level1)
403 {
404 uint64_t connCapability = CAPABILITY;
405 int32_t ret = LnnSetDLConnCapability(NODE1_NETWORK_ID, connCapability);
406 EXPECT_TRUE(ret == SOFTBUS_OK);
407 ret = LnnSetDLConnCapability(NODE2_NETWORK_ID, connCapability);
408 EXPECT_TRUE(ret == SOFTBUS_ERR);
409 }
410
411 /*
412 * @tc.name: LNN_SET_DLNODE_ADDR_Test_001
413 * @tc.desc: lnn set dl node addr test
414 * @tc.type: FUNC
415 * @tc.require:
416 */
417 HWTEST_F(DisctributedLedgerTest, LNN_SET_DLNODE_ADDR_Test_001, TestSize.Level1)
418 {
419 int32_t ret = LnnSetDLNodeAddr(NODE1_NETWORK_ID, CATEGORY_NETWORK_ID, NODE_ADDRESS);
420 EXPECT_TRUE(ret == SOFTBUS_OK);
421 ret = LnnSetDLNodeAddr(NODE2_NETWORK_ID, CATEGORY_NETWORK_ID, NODE_ADDRESS);
422 EXPECT_TRUE(ret == SOFTBUS_ERR);
423 }
424
425 /*
426 * @tc.name: LNN_GET_ONLINE_NODE_BY_UDID_HASH_Test_001
427 * @tc.desc: lnn get online node by udid hash test
428 * @tc.type: FUNC
429 * @tc.require:
430 */
431 HWTEST_F(DisctributedLedgerTest, LNN_GET_ONLINE_NODE_BY_UDID_HASH_Test_001, TestSize.Level1)
432 {
433 EXPECT_TRUE(LnnGetOnlineNodeByUdidHash(RECV_UDID_HASH) == nullptr);
434 }
435
436 /*
437 * @tc.name: LNN_REFRESH_DEVICE_ONLINE_STATE_AND_DEVICE_INFO_Test_001
438 * @tc.desc: lnn refresh device online state and device info test
439 * @tc.type: FUNC
440 * @tc.require:
441 */
442 HWTEST_F(DisctributedLedgerTest, LNN_REFRESH_DEVICE_ONLINE_STATE_AND_DEVICE_INFO_Test_001, TestSize.Level1)
443 {
444 DeviceInfo device;
445 InnerDeviceInfoAddtions addtions;
446 (void)memset_s(&device, sizeof(DeviceInfo), 0, sizeof(DeviceInfo));
447 (void)strcpy_s(device.devId, DISC_MAX_DEVICE_ID_LEN, NODE1_UDID);
448 addtions.medium = COAP;
449 LnnRefreshDeviceOnlineStateAndDevIdInfo(nullptr, &device, &addtions);
450 (void)memset_s(&device, sizeof(DeviceInfo), 0, sizeof(DeviceInfo));
451 (void)strcpy_s(device.devId, DISC_MAX_DEVICE_ID_LEN, RECV_UDID_HASH);
452 addtions.medium = BLE;
453 LnnRefreshDeviceOnlineStateAndDevIdInfo(nullptr, &device, &addtions);
454 }
455
456 /*
457 * @tc.name: LNN_GET_DATA_CHANGE_FLAG_Test_001
458 * @tc.desc: lnn get data change flag test
459 * @tc.type: FUNC
460 * @tc.require:
461 */
462 HWTEST_F(DisctributedLedgerTest, LNN_GET_DATA_CHANGE_FLAG_Test_001, TestSize.Level1)
463 {
464 int16_t info = 0;
465 int32_t ret = LnnGetRemoteNum16Info(NODE1_NETWORK_ID, NUM_KEY_DATA_CHANGE_FLAG, &info);
466 EXPECT_TRUE(ret == SOFTBUS_OK);
467 ret = LnnGetRemoteNum16Info(NODE2_NETWORK_ID, NUM_KEY_DATA_CHANGE_FLAG, &info);
468 EXPECT_TRUE(ret == SOFTBUS_ERR);
469 }
470
471 /*
472 * @tc.name: LNN_CONVERT_DLID_TO_UDID_Test_001
473 * @tc.desc: lnn convert dlid to udid test
474 * @tc.type: FUNC
475 * @tc.require:
476 */
477 HWTEST_F(DisctributedLedgerTest, LNN_CONVERT_DLID_TO_UDID_Test_001, TestSize.Level1)
478 {
479 EXPECT_TRUE(LnnConvertDLidToUdid(nullptr, CATEGORY_NETWORK_ID) == nullptr);
480 LnnConvertDLidToUdid(NODE1_NETWORK_ID, CATEGORY_NETWORK_ID);
481 EXPECT_TRUE(LnnConvertDLidToUdid(NODE2_NETWORK_ID, CATEGORY_NETWORK_ID) == nullptr);
482 }
483
484 /*
485 * @tc.name: LNN_GET_LNN_RELATION_Test_001
486 * @tc.desc: lnn get lnn relation test
487 * @tc.type: FUNC
488 * @tc.require:
489 */
490 HWTEST_F(DisctributedLedgerTest, LNN_GET_LNN_RELATION_Test_001, TestSize.Level1)
491 {
492 uint8_t relation[CONNECTION_ADDR_MAX] = {0};
493 int32_t ret = LnnGetLnnRelation(nullptr, CATEGORY_UDID, relation, CONNECTION_ADDR_MAX);
494 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
495 ret = LnnGetLnnRelation(NODE1_UDID, CATEGORY_UDID, relation, CONNECTION_ADDR_MAX);
496 EXPECT_TRUE(ret == SOFTBUS_OK);
497 ret = LnnGetLnnRelation(NODE2_UDID, CATEGORY_UDID, relation, CONNECTION_ADDR_MAX);
498 EXPECT_TRUE(ret == SOFTBUS_NOT_FIND);
499 }
500
501 /*
502 * @tc.name: LNN_SET_DL_DEVICE_INFO_NAME_Test_001
503 * @tc.desc: lnn set dl device info name test
504 * @tc.type: FUNC
505 * @tc.require:
506 */
507 HWTEST_F(DisctributedLedgerTest, LNN_SET_DL_DEVICE_INFO_NAME_Test_001, TestSize.Level1)
508 {
509 bool ret = LnnSetDLDeviceInfoName(nullptr, nullptr);
510 EXPECT_TRUE(ret == false);
511 ret = LnnSetDLDeviceInfoName(NODE1_UDID, NODE1_DEVICE_NAME);
512 EXPECT_TRUE(ret == true);
513 ret = LnnSetDLDeviceInfoName(NODE2_UDID, NODE2_DEVICE_NAME);
514 EXPECT_TRUE(ret == false);
515 }
516
517 /*
518 * @tc.name: LNN_GET_AND_SET_LANE_COUNT_Test_001
519 * @tc.desc: lnn get and set lane count test
520 * @tc.type: FUNC
521 * @tc.require:
522 */
523 HWTEST_F(DisctributedLedgerTest, LNN_GET_AND_SET_LANE_COUNT_Test_001, TestSize.Level1)
524 {
525 EXPECT_TRUE(LnnGetLaneCount(INVALID_LANE_ID) == SOFTBUS_ERR);
526 EXPECT_TRUE(LnnSetLaneCount(INVALID_LANE_ID, AUTH_ID) == SOFTBUS_ERR);
527 }
528 } // namespace OHOS
529