1 /*
2 * Copyright (c) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17 #include <securec.h>
18
19 #include "bus_center_adapter.h"
20 #include "bus_center_info_key.h"
21 #include "bus_center_manager.h"
22 #include "client_bus_center_manager.h"
23 #include "lnn_connection_addr_utils.h"
24 #include "lnn_distributed_net_ledger.h"
25 #include "lnn_huks_utils.h"
26 #include "lnn_local_net_ledger.h"
27 #include "lnn_log.h"
28 #include "lnn_meta_node_ledger.h"
29 #include "lnn_net_ledger.c"
30 #include "lnn_net_ledger.h"
31 #include "lnn_network_id.h"
32 #include "lnn_node_info.h"
33 #include "lnn_sync_item_info.h"
34 #include "message_handler.h"
35 #include "softbus_adapter_mem.h"
36 #include "softbus_bus_center.h"
37 #include "softbus_error_code.h"
38 #include "softbus_utils.h"
39
40 namespace OHOS {
41 using namespace testing::ext;
42 constexpr char NODE1_DEVICE_NAME[] = "node1_test";
43 constexpr char NODE1_UDID[] = "123456ABCDEF";
44 constexpr char NODE1_NETWORK_ID[] = "235689BNHFCF";
45 constexpr char NODE1_UUID[] = "235689BNHFCC";
46 constexpr char NODE1_BT_MAC[] = "56789TTU";
47 constexpr uint32_t NODE1_AUTH_SEQ_NUM = 100;
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 CHANGE_DEVICE_NAME[] = "change_test";
54 constexpr char NODE5_NETWORK_ID[] = "235689BNHFCZ";
55 constexpr uint32_t REMOTE_PROXY_PORT = 8080;
56 constexpr uint32_t REMOTE_AUTH_PORT = 7070;
57 constexpr uint32_t REMOTE_SESSION_PORT = 6060;
58 constexpr uint32_t NODE_NUM = 4;
59 constexpr char LOCAL_UDID[] = "123456LOCALTEST";
60 constexpr char LOCAL_NETWORKID[] = "235689LOCAL";
61 constexpr char LOCAL_UUID[] = "235999LOCAL";
62 constexpr char LOCAL_DEVNAME[] = "local_test";
63 constexpr char LOCAL_CHANAGE_DEVNAME[] = "local";
64 constexpr char LOCAL_BT_MAC[] = "56789TUT";
65 constexpr char LOCAL_WLAN_IP[] = "10.146.181.134";
66 constexpr char LOCAL_DEVTYPE[] = TYPE_WATCH;
67 constexpr uint32_t LOCAL_SESSION_PORT = 5000;
68 constexpr uint32_t LOCAL_AUTH_PORT = 6000;
69 constexpr uint32_t LOCAL_PROXY_PORT = 7000;
70 constexpr uint32_t BR_NUM = 0;
71 constexpr uint32_t WLAN2P4G_NUM = 1;
72 static NodeInfo g_nodeInfo[NODE_NUM];
73 constexpr uint32_t LOCAL_MAX_SIZE = 128;
74
75 class LedgerLaneHubTest : public testing::Test {
76 public:
77 static void SetUpTestCase();
78 static void TearDownTestCase();
79 void SetUp();
80 void TearDown();
81 };
82
SetUpTestCase()83 void LedgerLaneHubTest::SetUpTestCase()
84 {
85 int32_t ret = LooperInit();
86 EXPECT_TRUE(ret == SOFTBUS_OK);
87 ret = LnnInitDistributedLedger();
88 EXPECT_TRUE(ret == SOFTBUS_OK);
89 ret = LnnInitLocalLedger();
90 EXPECT_TRUE(ret == SOFTBUS_OK);
91 GTEST_LOG_(INFO) << "LaneHubTest start.";
92 }
93
TearDownTestCase()94 void LedgerLaneHubTest::TearDownTestCase()
95 {
96 LnnDeinitLocalLedger();
97 LnnDeinitDistributedLedger();
98 LooperDeinit();
99 GTEST_LOG_(INFO) << "LaneHubTest end.";
100 }
101
SetUp()102 void LedgerLaneHubTest::SetUp() { }
103
TearDown()104 void LedgerLaneHubTest::TearDown() { }
105
ConstructBRNode(void)106 static void ConstructBRNode(void)
107 {
108 int32_t ret;
109 uint32_t cap = 0;
110 LnnSetNetCapability(&cap, BIT_BR);
111 g_nodeInfo[BR_NUM].netCapacity = cap;
112 ret = LnnSetDeviceUdid(&g_nodeInfo[BR_NUM], NODE1_UDID);
113 EXPECT_TRUE(ret == SOFTBUS_OK);
114 LnnSetBtMac(&g_nodeInfo[BR_NUM], NODE1_BT_MAC);
115 ret = LnnSetDeviceName(&g_nodeInfo[BR_NUM].deviceInfo, NODE1_DEVICE_NAME);
116 EXPECT_TRUE(ret == SOFTBUS_OK);
117 ret = strncpy_s(g_nodeInfo[BR_NUM].networkId, NETWORK_ID_BUF_LEN, NODE1_NETWORK_ID, strlen(NODE1_NETWORK_ID));
118 EXPECT_TRUE(ret == EOK);
119 ret = strncpy_s(g_nodeInfo[BR_NUM].uuid, UUID_BUF_LEN, NODE1_UUID, strlen(NODE1_UUID));
120 EXPECT_TRUE(ret == EOK);
121 g_nodeInfo[BR_NUM].authSeqNum = NODE1_AUTH_SEQ_NUM;
122 ret = LnnSetDiscoveryType(&g_nodeInfo[BR_NUM], DISCOVERY_TYPE_BR);
123 EXPECT_TRUE(ret == SOFTBUS_OK);
124 }
125
ConstructWlan2P4GNode(void)126 static void ConstructWlan2P4GNode(void)
127 {
128 int32_t ret;
129 uint32_t cap = 0;
130 LnnSetNetCapability(&cap, BIT_WIFI_24G);
131 g_nodeInfo[WLAN2P4G_NUM].netCapacity = cap;
132 ret = LnnSetDeviceUdid(&g_nodeInfo[WLAN2P4G_NUM], NODE2_UDID);
133 EXPECT_TRUE(ret == SOFTBUS_OK);
134 LnnSetBtMac(&g_nodeInfo[WLAN2P4G_NUM], NODE2_BT_MAC);
135 ret = LnnSetDeviceName(&g_nodeInfo[WLAN2P4G_NUM].deviceInfo, NODE2_DEVICE_NAME);
136 EXPECT_TRUE(ret == SOFTBUS_OK);
137 ret = strncpy_s(g_nodeInfo[WLAN2P4G_NUM].networkId, NETWORK_ID_BUF_LEN, NODE2_NETWORK_ID, strlen(NODE2_NETWORK_ID));
138 EXPECT_TRUE(ret == EOK);
139 ret = strncpy_s(g_nodeInfo[WLAN2P4G_NUM].uuid, UUID_BUF_LEN, NODE2_UUID, strlen(NODE2_UUID));
140 EXPECT_TRUE(ret == EOK);
141 g_nodeInfo[WLAN2P4G_NUM].authSeqNum = NODE1_AUTH_SEQ_NUM;
142 ret = LnnSetDiscoveryType(&g_nodeInfo[WLAN2P4G_NUM], DISCOVERY_TYPE_BLE);
143 EXPECT_TRUE(ret == SOFTBUS_OK);
144 ret = LnnSetProxyPort(&g_nodeInfo[WLAN2P4G_NUM], REMOTE_PROXY_PORT);
145 EXPECT_TRUE(ret == SOFTBUS_OK);
146 ret = LnnSetSessionPort(&g_nodeInfo[WLAN2P4G_NUM], REMOTE_SESSION_PORT);
147 EXPECT_TRUE(ret == SOFTBUS_OK);
148 LnnSetWiFiIp(&g_nodeInfo[WLAN2P4G_NUM], LOCAL_WLAN_IP);
149 ret = LnnSetAuthPort(&g_nodeInfo[WLAN2P4G_NUM], REMOTE_AUTH_PORT);
150 EXPECT_TRUE(ret == SOFTBUS_OK);
151 }
152
ConstructCommonLocalInfo(void)153 static void ConstructCommonLocalInfo(void)
154 {
155 int32_t ret = LnnSetLocalStrInfo(STRING_KEY_DEV_UDID, LOCAL_UDID);
156 EXPECT_TRUE(ret == SOFTBUS_OK);
157 ret = LnnSetLocalStrInfo(STRING_KEY_NETWORKID, LOCAL_NETWORKID);
158 EXPECT_TRUE(ret == SOFTBUS_OK);
159 ret = LnnSetLocalStrInfo(STRING_KEY_UUID, LOCAL_UUID);
160 EXPECT_TRUE(ret == SOFTBUS_OK);
161 ret = LnnSetLocalStrInfo(STRING_KEY_DEV_TYPE, LOCAL_DEVTYPE);
162 EXPECT_TRUE(ret == SOFTBUS_OK);
163 ret = LnnSetLocalStrInfo(STRING_KEY_DEV_NAME, LOCAL_DEVNAME);
164 EXPECT_TRUE(ret == SOFTBUS_OK);
165 }
166
ConstructBtLocalInfo(void)167 static void ConstructBtLocalInfo(void)
168 {
169 int32_t ret = LnnSetLocalStrInfo(STRING_KEY_BT_MAC, LOCAL_BT_MAC);
170 EXPECT_TRUE(ret == SOFTBUS_OK);
171 ret = LnnSetLocalNumInfo(NUM_KEY_NET_CAP, 1 << BIT_BR);
172 EXPECT_TRUE(ret == SOFTBUS_OK);
173 }
174
ConstructWiFiLocalInfo(bool is5G)175 static void ConstructWiFiLocalInfo(bool is5G)
176 {
177 int32_t ret = LnnSetLocalNumInfo(NUM_KEY_AUTH_PORT, LOCAL_AUTH_PORT);
178 EXPECT_TRUE(ret == SOFTBUS_OK);
179 ret = LnnSetLocalNumInfo(NUM_KEY_PROXY_PORT, LOCAL_PROXY_PORT);
180 EXPECT_TRUE(ret == SOFTBUS_OK);
181 ret = LnnSetLocalNumInfo(NUM_KEY_SESSION_PORT, LOCAL_SESSION_PORT);
182 EXPECT_TRUE(ret == SOFTBUS_OK);
183 if (is5G) {
184 ret = LnnSetLocalNumInfo(NUM_KEY_NET_CAP, 1 << BIT_WIFI_5G);
185 } else {
186 ret = LnnSetLocalNumInfo(NUM_KEY_NET_CAP, 1 << BIT_WIFI_24G);
187 }
188 EXPECT_TRUE(ret == SOFTBUS_OK);
189 ret = LnnSetLocalStrInfo(STRING_KEY_WLAN_IP, LOCAL_WLAN_IP);
190 EXPECT_TRUE(ret == SOFTBUS_OK);
191 }
192
GetCommonLocalInfo(void)193 static void GetCommonLocalInfo(void)
194 {
195 int32_t ret;
196 char des[LOCAL_MAX_SIZE] = { 0 };
197 ret = LnnGetLocalStrInfo(STRING_KEY_DEV_UDID, des, LOCAL_MAX_SIZE);
198 EXPECT_TRUE((ret == SOFTBUS_OK) && (strcmp(des, LOCAL_UDID) == 0));
199 ret = LnnGetLocalStrInfo(STRING_KEY_NETWORKID, des, LOCAL_MAX_SIZE);
200 EXPECT_TRUE((ret == SOFTBUS_OK) && (strcmp(des, LOCAL_NETWORKID) == 0));
201 ret = LnnGetLocalStrInfo(STRING_KEY_UUID, des, LOCAL_MAX_SIZE);
202 EXPECT_TRUE((ret == SOFTBUS_OK) && (strcmp(des, LOCAL_UUID) == 0));
203 ret = LnnGetLocalStrInfo(STRING_KEY_DEV_TYPE, des, LOCAL_MAX_SIZE);
204 EXPECT_TRUE((ret == SOFTBUS_OK) && (strcmp(des, LOCAL_DEVTYPE) == 0));
205 ret = LnnGetLocalStrInfo(STRING_KEY_DEV_NAME, des, LOCAL_MAX_SIZE);
206 EXPECT_TRUE((ret == SOFTBUS_OK) && (strcmp(des, LOCAL_DEVNAME) == 0));
207 }
208
GetBTLocalInfo(void)209 static void GetBTLocalInfo(void)
210 {
211 int32_t ret;
212 char des[LOCAL_MAX_SIZE] = { 0 };
213 ret = LnnGetLocalStrInfo(STRING_KEY_BT_MAC, des, LOCAL_MAX_SIZE);
214 EXPECT_TRUE((ret == SOFTBUS_OK) && (strcmp(des, LOCAL_BT_MAC) == 0));
215 }
216
GetWiFiLocalInfo(void)217 static void GetWiFiLocalInfo(void)
218 {
219 int32_t ret;
220 int32_t port = 0;
221 ret = LnnGetLocalNumInfo(NUM_KEY_AUTH_PORT, &port);
222 EXPECT_TRUE((ret == SOFTBUS_OK) && (port == LOCAL_AUTH_PORT));
223 ret = LnnGetLocalNumInfo(NUM_KEY_PROXY_PORT, &port);
224 EXPECT_TRUE((ret == SOFTBUS_OK) && (port == LOCAL_PROXY_PORT));
225 ret = LnnGetLocalNumInfo(NUM_KEY_SESSION_PORT, &port);
226 EXPECT_TRUE((ret == SOFTBUS_OK) && (port == LOCAL_SESSION_PORT));
227 }
228
229 /*
230 * @tc.name: SOFTBUS_DUMP_PRINT_NET_CAPACITY_Test_001
231 * @tc.desc: SoftbusDumpPrintDynamicNetCap test
232 * @tc.type: FUNC
233 * @tc.require:
234 */
235 HWTEST_F(LedgerLaneHubTest, SOFTBUS_DUMP_PRINT_NET_CAPACITY_Test_001, TestSize.Level1)
236 {
237 int32_t fd = 0;
238 NodeBasicInfo nodeInfo;
239
240 (void)memset_s(&nodeInfo, sizeof(NodeBasicInfo), 0, sizeof(NodeBasicInfo));
241 (void)strncpy_s(nodeInfo.networkId, NETWORK_ID_BUF_LEN, NODE5_NETWORK_ID, strlen(NODE5_NETWORK_ID));
242 EXPECT_NE(SoftbusDumpPrintDynamicNetCap(fd, &nodeInfo), SOFTBUS_OK);
243
244 ConstructCommonLocalInfo();
245 ConstructWiFiLocalInfo(true);
246
247 (void)memset_s(&nodeInfo, sizeof(NodeBasicInfo), 0, sizeof(NodeBasicInfo));
248 (void)strncpy_s(nodeInfo.networkId, NETWORK_ID_BUF_LEN, LOCAL_NETWORKID, strlen(LOCAL_NETWORKID));
249 EXPECT_EQ(SoftbusDumpPrintDynamicNetCap(fd, &nodeInfo), SOFTBUS_OK);
250 }
251
252 /*
253 * @tc.name: SOFTBUS_DUMP_PRINT_NET_TYPE_Test_001
254 * @tc.desc: SoftbusDumpPrintNetType test
255 * @tc.type: FUNC
256 * @tc.require:
257 */
258 HWTEST_F(LedgerLaneHubTest, SOFTBUS_DUMP_PRINT_NET_TYPE_Test_001, TestSize.Level1)
259 {
260 int32_t fd = 0;
261 NodeBasicInfo nodeInfo;
262
263 (void)memset_s(&nodeInfo, sizeof(NodeBasicInfo), 0, sizeof(NodeBasicInfo));
264 (void)strncpy_s(nodeInfo.networkId, NETWORK_ID_BUF_LEN, NODE5_NETWORK_ID, strlen(NODE5_NETWORK_ID));
265 EXPECT_NE(SoftbusDumpPrintNetType(fd, &nodeInfo), SOFTBUS_OK);
266
267 ConstructCommonLocalInfo();
268 ConstructWiFiLocalInfo(true);
269
270 (void)memset_s(&nodeInfo, sizeof(NodeBasicInfo), 0, sizeof(NodeBasicInfo));
271 (void)strncpy_s(nodeInfo.networkId, NETWORK_ID_BUF_LEN, LOCAL_NETWORKID, strlen(LOCAL_NETWORKID));
272 EXPECT_EQ(SoftbusDumpPrintNetType(fd, &nodeInfo), SOFTBUS_OK);
273 }
274
275 /*
276 * @tc.name: LNN_SET_NODE_DATA_CHANGE_FLAG_Test_001
277 * @tc.desc: Lnn Set Node Data Change Flag test
278 * @tc.type: FUNC
279 * @tc.require:
280 */
281 HWTEST_F(LedgerLaneHubTest, LNN_SET_NODE_DATA_CHANGE_FLAG_Test_001, TestSize.Level1)
282 {
283 char *networkId = nullptr;
284 char networkIdSecond[NETWORK_ID_BUF_LEN] = "1234";
285 uint16_t dataChangeFlag = 0;
286 EXPECT_NE(LnnSetNodeDataChangeFlag(networkId, dataChangeFlag), SOFTBUS_OK);
287 EXPECT_EQ(LnnSetNodeDataChangeFlag(networkIdSecond, dataChangeFlag), SOFTBUS_NETWORK_INVALID_DEV_INFO);
288
289 ConstructCommonLocalInfo();
290 EXPECT_EQ(LnnSetNodeDataChangeFlag(LOCAL_NETWORKID, dataChangeFlag), SOFTBUS_OK);
291 }
292
293 /*
294 * @tc.name: LNN_SET_DATA_CHANGE_FLAG_Test_001
295 * @tc.desc: Lnn Set Data Change Flag test
296 * @tc.type: FUNC
297 * @tc.require:
298 */
299 HWTEST_F(LedgerLaneHubTest, LNN_SET_DATA_CHANGE_FLAG_Test_001, TestSize.Level1)
300 {
301 NodeInfo info;
302 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
303 NodeInfo *nodeinfo = nullptr;
304 uint16_t dataChangeFlag = 0;
305 EXPECT_TRUE(LnnSetDataChangeFlag(nodeinfo, dataChangeFlag) == SOFTBUS_INVALID_PARAM);
306 nodeinfo = &info;
307 EXPECT_TRUE(LnnSetDataChangeFlag(nodeinfo, dataChangeFlag) == SOFTBUS_OK);
308 }
309
310 /*
311 * @tc.name: LNN_GET_DATA_CHANGE_FLAG_Test_001
312 * @tc.desc: Lnn Get Data Change Flag test
313 * @tc.type: FUNC
314 * @tc.require:
315 */
316 HWTEST_F(LedgerLaneHubTest, LNN_GET_DATA_CHANGE_FLAG_Test_001, TestSize.Level1)
317 {
318 NodeInfo info;
319 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
320 NodeInfo *nodeinfo = nullptr;
321 EXPECT_TRUE(LnnGetDataChangeFlag(nodeinfo) == 0);
322 nodeinfo = &info;
323 EXPECT_TRUE(LnnGetDataChangeFlag(nodeinfo) == 0);
324 }
325
326 /*
327 * @tc.name: LNN_GET_LOCAL_STR_INFO_Test_001
328 * @tc.desc: Lnn Get Local Str Info test
329 * @tc.type: FUNC
330 * @tc.require:
331 */
332 HWTEST_F(LedgerLaneHubTest, LNN_GET_LOCAL_STR_INFO_Test_001, TestSize.Level1)
333 {
334 NodeInfo info;
335 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
336 char *nodeInfo = reinterpret_cast<char *>(&info);
337 uint32_t len = 0;
338 EXPECT_TRUE(LnnSetLocalStrInfo(NUM_KEY_DATA_CHANGE_FLAG, nodeInfo) == SOFTBUS_INVALID_PARAM);
339 EXPECT_TRUE(LnnGetLocalStrInfo(NUM_KEY_AUTH_PORT, nodeInfo, len) == SOFTBUS_INVALID_PARAM);
340 EXPECT_TRUE(LnnGetLocalStrInfo(NUM_KEY_SESSION_PORT, nodeInfo, len) == SOFTBUS_INVALID_PARAM);
341 EXPECT_TRUE(LnnGetLocalStrInfo(NUM_KEY_PROXY_PORT, nodeInfo, len) == SOFTBUS_INVALID_PARAM);
342 EXPECT_TRUE(LnnGetLocalStrInfo(NUM_KEY_NET_CAP, nodeInfo, len) == SOFTBUS_INVALID_PARAM);
343 EXPECT_TRUE(LnnGetLocalStrInfo(NUM_KEY_DISCOVERY_TYPE, nodeInfo, len) == SOFTBUS_INVALID_PARAM);
344 EXPECT_TRUE(LnnGetLocalStrInfo(NUM_KEY_DEV_TYPE_ID, nodeInfo, len) == SOFTBUS_INVALID_PARAM);
345 EXPECT_TRUE(LnnGetLocalStrInfo(NUM_KEY_MASTER_NODE_WEIGHT, nodeInfo, len) == SOFTBUS_INVALID_PARAM);
346 EXPECT_TRUE(LnnGetLocalStrInfo(NUM_KEY_P2P_ROLE, nodeInfo, len) == SOFTBUS_INVALID_PARAM);
347 EXPECT_TRUE(LnnGetLocalStrInfo(NUM_KEY_DATA_CHANGE_FLAG, nodeInfo, len) == SOFTBUS_INVALID_PARAM);
348 }
349
350 /*
351 * @tc.name: LNN_INIT_LOCAL_LEDGER_DELAY_Test_001
352 * @tc.desc: Lnn Init Local Ledger Delay test
353 * @tc.type: FUNC
354 * @tc.require:
355 */
356 HWTEST_F(LedgerLaneHubTest, LNN_INIT_LOCAL_LEDGER_DELAY_Test_001, TestSize.Level1)
357 {
358 EXPECT_EQ(LnnInitLocalLedgerDelay(), SOFTBUS_OK);
359 }
360
361 /*
362 * @tc.name: LEDGER_GetDistributedLedgerNode_Test_001
363 * @tc.desc: Get distributed ledger node info.
364 * @tc.type: FUNC
365 * @tc.require: AR000FK6J0
366 */
367 HWTEST_F(LedgerLaneHubTest, LEDGER_GetDistributedLedgerNode_Test_001, TestSize.Level1)
368 {
369 ConstructBRNode();
370 ConstructWlan2P4GNode();
371 LnnAddOnlineNode(&g_nodeInfo[BR_NUM]);
372 LnnAddOnlineNode(&g_nodeInfo[WLAN2P4G_NUM]);
373 LnnRemoveNode(NODE1_UDID);
374 LnnRemoveNode(NODE2_UDID);
375 }
376
377 /*
378 * @tc.name: LEDGER_GetDistributedLedgerInfo_Test_001
379 * @tc.desc: test of the LnnGetRemoteStrInfo LnnGetDLNumInfo function
380 * @tc.type: FUNC
381 * @tc.require: AR000FK6J0
382 */
383 HWTEST_F(LedgerLaneHubTest, LEDGER_GetDistributedLedgerInfo_Test_001, TestSize.Level1)
384 {
385 char deviceName[DEVICE_NAME_BUF_LEN] = { 0 };
386 char macAddr[MAC_LEN] = { 0 };
387 int32_t ret;
388 uint32_t cap = 0;
389 ConstructBRNode();
390 LnnAddOnlineNode(&g_nodeInfo[BR_NUM]);
391
392 // STRING_KEY_DEV_NAME
393 ret = LnnGetRemoteStrInfo(NODE1_NETWORK_ID, STRING_KEY_DEV_NAME, deviceName, DEVICE_NAME_BUF_LEN);
394 EXPECT_TRUE(ret == SOFTBUS_OK);
395 EXPECT_TRUE(strcmp(deviceName, NODE1_DEVICE_NAME) == 0);
396
397 // STRING_KEY_BT_MAC
398 ret = LnnGetRemoteStrInfo(NODE1_NETWORK_ID, STRING_KEY_BT_MAC, macAddr, MAC_LEN);
399 EXPECT_TRUE(ret == SOFTBUS_OK);
400 EXPECT_TRUE(strcmp(macAddr, NODE1_BT_MAC) == 0);
401
402 // NUM_KEY_NET_CAP
403 ret = LnnGetRemoteNumU32Info(NODE1_NETWORK_ID, NUM_KEY_NET_CAP, &cap);
404 EXPECT_TRUE(ret == SOFTBUS_OK);
405 EXPECT_TRUE((cap & (1 << BIT_BR)) != 0);
406
407 LnnRemoveNode(NODE1_UDID);
408 }
409
410 /*
411 * @tc.name: LEDGER_DistributedLedgerChangeName_Test_001
412 * @tc.desc: test of the LnnGetRemoteStrInfo LnnSetDLDeviceInfoName function
413 * @tc.type: FUNC
414 * @tc.require: AR000FK6J0
415 */
416 HWTEST_F(LedgerLaneHubTest, LEDGER_DistributedLedgerChangeName_Test_001, TestSize.Level1)
417 {
418 char deviceName[DEVICE_NAME_BUF_LEN] = { 0 };
419 ConstructWlan2P4GNode();
420 LnnAddOnlineNode(&g_nodeInfo[WLAN2P4G_NUM]);
421
422 // change name
423 bool result = LnnSetDLDeviceInfoName(NODE2_UDID, CHANGE_DEVICE_NAME);
424 EXPECT_TRUE(result);
425 // STRING_KEY_DEV_NAME
426 int32_t ret = LnnGetRemoteStrInfo(NODE2_NETWORK_ID, STRING_KEY_DEV_NAME, deviceName, DEVICE_NAME_BUF_LEN);
427 EXPECT_TRUE(ret == SOFTBUS_OK);
428 EXPECT_TRUE(strcmp(deviceName, CHANGE_DEVICE_NAME) == 0);
429 LnnRemoveNode(NODE2_UDID);
430 }
431
432 /*
433 * @tc.name: LEDGER_LocalLedgerGetInfo_Test_001
434 * @tc.desc: Performance test of the LnnGetLocalLedgerStrInfo and NumInfo function.
435 * @tc.type: FUNC
436 * @tc.require: AR000FK6J0
437 */
438 HWTEST_F(LedgerLaneHubTest, LEDGER_LocalLedgerGetInfo_Test_001, TestSize.Level1)
439 {
440 char des[LOCAL_MAX_SIZE] = { 0 };
441 int32_t ret;
442 ConstructCommonLocalInfo();
443 ConstructBtLocalInfo();
444 ConstructWiFiLocalInfo(false);
445 GetCommonLocalInfo();
446 GetBTLocalInfo();
447 GetWiFiLocalInfo();
448
449 // change devicename
450 ret = LnnSetLocalStrInfo(STRING_KEY_DEV_NAME, LOCAL_CHANAGE_DEVNAME);
451 EXPECT_TRUE(ret == SOFTBUS_OK);
452 ret = LnnGetLocalStrInfo(STRING_KEY_DEV_NAME, des, LOCAL_MAX_SIZE);
453 EXPECT_TRUE((ret == SOFTBUS_OK) && (strcmp(des, LOCAL_CHANAGE_DEVNAME) == 0));
454 }
455 } // namespace OHOS
456