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_network_id.h"
30 #include "lnn_net_ledger.h"
31 #include "lnn_net_ledger.c"
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_errcode.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 {
104 }
105
TearDown()106 void LedgerLaneHubTest::TearDown()
107 {
108 }
109
ConstructBRNode(void)110 static void ConstructBRNode(void)
111 {
112 int32_t ret;
113 uint32_t cap = 0;
114 LnnSetNetCapability(&cap, BIT_BR);
115 g_nodeInfo[BR_NUM].netCapacity = cap;
116 ret = LnnSetDeviceUdid(&g_nodeInfo[BR_NUM], NODE1_UDID);
117 EXPECT_TRUE(ret == SOFTBUS_OK);
118 LnnSetBtMac(&g_nodeInfo[BR_NUM], NODE1_BT_MAC);
119 ret = LnnSetDeviceName(&g_nodeInfo[BR_NUM].deviceInfo, NODE1_DEVICE_NAME);
120 EXPECT_TRUE(ret == SOFTBUS_OK);
121 ret = strncpy_s(g_nodeInfo[BR_NUM].networkId, NETWORK_ID_BUF_LEN, NODE1_NETWORK_ID, strlen(NODE1_NETWORK_ID));
122 EXPECT_TRUE(ret == EOK);
123 ret = strncpy_s(g_nodeInfo[BR_NUM].uuid, UUID_BUF_LEN, NODE1_UUID, strlen(NODE1_UUID));
124 EXPECT_TRUE(ret == EOK);
125 g_nodeInfo[BR_NUM].authSeqNum = NODE1_AUTH_SEQ_NUM;
126 ret = LnnSetDiscoveryType(&g_nodeInfo[BR_NUM], DISCOVERY_TYPE_BR);
127 EXPECT_TRUE(ret == SOFTBUS_OK);
128 }
129
ConstructWlan2P4GNode(void)130 static void ConstructWlan2P4GNode(void)
131 {
132 int32_t ret;
133 uint32_t cap = 0;
134 LnnSetNetCapability(&cap, BIT_WIFI_24G);
135 g_nodeInfo[WLAN2P4G_NUM].netCapacity = cap;
136 ret = LnnSetDeviceUdid(&g_nodeInfo[WLAN2P4G_NUM], NODE2_UDID);
137 EXPECT_TRUE(ret == SOFTBUS_OK);
138 LnnSetBtMac(&g_nodeInfo[WLAN2P4G_NUM], NODE2_BT_MAC);
139 ret = LnnSetDeviceName(&g_nodeInfo[WLAN2P4G_NUM].deviceInfo, NODE2_DEVICE_NAME);
140 EXPECT_TRUE(ret == SOFTBUS_OK);
141 ret = strncpy_s(g_nodeInfo[WLAN2P4G_NUM].networkId, NETWORK_ID_BUF_LEN, NODE2_NETWORK_ID, strlen(NODE2_NETWORK_ID));
142 EXPECT_TRUE(ret == EOK);
143 ret = strncpy_s(g_nodeInfo[WLAN2P4G_NUM].uuid, UUID_BUF_LEN, NODE2_UUID, strlen(NODE2_UUID));
144 EXPECT_TRUE(ret == EOK);
145 g_nodeInfo[WLAN2P4G_NUM].authSeqNum = NODE1_AUTH_SEQ_NUM;
146 ret = LnnSetDiscoveryType(&g_nodeInfo[WLAN2P4G_NUM], DISCOVERY_TYPE_BLE);
147 EXPECT_TRUE(ret == SOFTBUS_OK);
148 ret = LnnSetProxyPort(&g_nodeInfo[WLAN2P4G_NUM], REMOTE_PROXY_PORT);
149 EXPECT_TRUE(ret == SOFTBUS_OK);
150 ret = LnnSetSessionPort(&g_nodeInfo[WLAN2P4G_NUM], REMOTE_SESSION_PORT);
151 EXPECT_TRUE(ret == SOFTBUS_OK);
152 LnnSetWiFiIp(&g_nodeInfo[WLAN2P4G_NUM], LOCAL_WLAN_IP);
153 ret = LnnSetAuthPort(&g_nodeInfo[WLAN2P4G_NUM], REMOTE_AUTH_PORT);
154 EXPECT_TRUE(ret == SOFTBUS_OK);
155 }
156
ConstructCommonLocalInfo(void)157 static void ConstructCommonLocalInfo(void)
158 {
159 int32_t ret = LnnSetLocalStrInfo(STRING_KEY_DEV_UDID, LOCAL_UDID);
160 EXPECT_TRUE(ret == SOFTBUS_OK);
161 ret = LnnSetLocalStrInfo(STRING_KEY_NETWORKID, LOCAL_NETWORKID);
162 EXPECT_TRUE(ret == SOFTBUS_OK);
163 ret = LnnSetLocalStrInfo(STRING_KEY_UUID, LOCAL_UUID);
164 EXPECT_TRUE(ret == SOFTBUS_OK);
165 ret = LnnSetLocalStrInfo(STRING_KEY_DEV_TYPE, LOCAL_DEVTYPE);
166 EXPECT_TRUE(ret == SOFTBUS_OK);
167 ret = LnnSetLocalStrInfo(STRING_KEY_DEV_NAME, LOCAL_DEVNAME);
168 EXPECT_TRUE(ret == SOFTBUS_OK);
169 }
170
ConstructBtLocalInfo(void)171 static void ConstructBtLocalInfo(void)
172 {
173 int32_t ret = LnnSetLocalStrInfo(STRING_KEY_BT_MAC, LOCAL_BT_MAC);
174 EXPECT_TRUE(ret == SOFTBUS_OK);
175 ret = LnnSetLocalNumInfo(NUM_KEY_NET_CAP, 1 << BIT_BR);
176 EXPECT_TRUE(ret == SOFTBUS_OK);
177 }
178
ConstructWiFiLocalInfo(bool is5G)179 static void ConstructWiFiLocalInfo(bool is5G)
180 {
181 int32_t ret = LnnSetLocalNumInfo(NUM_KEY_AUTH_PORT, LOCAL_AUTH_PORT);
182 EXPECT_TRUE(ret == SOFTBUS_OK);
183 ret = LnnSetLocalNumInfo(NUM_KEY_PROXY_PORT, LOCAL_PROXY_PORT);
184 EXPECT_TRUE(ret == SOFTBUS_OK);
185 ret = LnnSetLocalNumInfo(NUM_KEY_SESSION_PORT, LOCAL_SESSION_PORT);
186 EXPECT_TRUE(ret == SOFTBUS_OK);
187 if (is5G) {
188 ret = LnnSetLocalNumInfo(NUM_KEY_NET_CAP, 1 << BIT_WIFI_5G);
189 } else {
190 ret = LnnSetLocalNumInfo(NUM_KEY_NET_CAP, 1 << BIT_WIFI_24G);
191 }
192 EXPECT_TRUE(ret == SOFTBUS_OK);
193 ret = LnnSetLocalStrInfo(STRING_KEY_WLAN_IP, LOCAL_WLAN_IP);
194 EXPECT_TRUE(ret == SOFTBUS_OK);
195 }
196
GetCommonLocalInfo(void)197 static void GetCommonLocalInfo(void)
198 {
199 int32_t ret;
200 char des[LOCAL_MAX_SIZE] = {0};
201 ret = LnnGetLocalStrInfo(STRING_KEY_DEV_UDID, des, LOCAL_MAX_SIZE);
202 EXPECT_TRUE((ret == SOFTBUS_OK) && (strcmp(des, LOCAL_UDID) == 0));
203 ret = LnnGetLocalStrInfo(STRING_KEY_NETWORKID, des, LOCAL_MAX_SIZE);
204 EXPECT_TRUE((ret == SOFTBUS_OK) && (strcmp(des, LOCAL_NETWORKID) == 0));
205 ret = LnnGetLocalStrInfo(STRING_KEY_UUID, des, LOCAL_MAX_SIZE);
206 EXPECT_TRUE((ret == SOFTBUS_OK) && (strcmp(des, LOCAL_UUID) == 0));
207 ret = LnnGetLocalStrInfo(STRING_KEY_DEV_TYPE, des, LOCAL_MAX_SIZE);
208 EXPECT_TRUE((ret == SOFTBUS_OK) && (strcmp(des, LOCAL_DEVTYPE) == 0));
209 ret = LnnGetLocalStrInfo(STRING_KEY_DEV_NAME, des, LOCAL_MAX_SIZE);
210 EXPECT_TRUE((ret == SOFTBUS_OK) && (strcmp(des, LOCAL_DEVNAME) == 0));
211 }
212
GetBTLocalInfo(void)213 static void GetBTLocalInfo(void)
214 {
215 int32_t ret;
216 char des[LOCAL_MAX_SIZE] = {0};
217 ret = LnnGetLocalStrInfo(STRING_KEY_BT_MAC, des, LOCAL_MAX_SIZE);
218 EXPECT_TRUE((ret == SOFTBUS_OK) && (strcmp(des, LOCAL_BT_MAC) == 0));
219 }
220
GetWiFiLocalInfo(void)221 static void GetWiFiLocalInfo(void)
222 {
223 int32_t ret;
224 int32_t port = 0;
225 ret = LnnGetLocalNumInfo(NUM_KEY_AUTH_PORT, &port);
226 EXPECT_TRUE((ret == SOFTBUS_OK) && (port == LOCAL_AUTH_PORT));
227 ret = LnnGetLocalNumInfo(NUM_KEY_PROXY_PORT, &port);
228 EXPECT_TRUE((ret == SOFTBUS_OK) && (port == LOCAL_PROXY_PORT));
229 ret = LnnGetLocalNumInfo(NUM_KEY_SESSION_PORT, &port);
230 EXPECT_TRUE((ret == SOFTBUS_OK) && (port == LOCAL_SESSION_PORT));
231 }
232
233 /*
234 * @tc.name: SOFTBUS_DUMP_PRINT_NET_CAPACITY_Test_001
235 * @tc.desc: SoftbusDumpPrintNetCapacity test
236 * @tc.type: FUNC
237 * @tc.require:
238 */
239 HWTEST_F(LedgerLaneHubTest, SOFTBUS_DUMP_PRINT_NET_CAPACITY_Test_001, TestSize.Level1)
240 {
241 int fd = 0;
242 NodeBasicInfo nodeInfo;
243
244 (void)memset_s(&nodeInfo, sizeof(NodeBasicInfo), 0, sizeof(NodeBasicInfo));
245 (void)strncpy_s(nodeInfo.networkId, NETWORK_ID_BUF_LEN, NODE5_NETWORK_ID, strlen(NODE5_NETWORK_ID));
246 EXPECT_NE(SoftbusDumpPrintNetCapacity(fd, &nodeInfo), SOFTBUS_OK);
247
248 ConstructCommonLocalInfo();
249 ConstructWiFiLocalInfo(true);
250
251 (void)memset_s(&nodeInfo, sizeof(NodeBasicInfo), 0, sizeof(NodeBasicInfo));
252 (void)strncpy_s(nodeInfo.networkId, NETWORK_ID_BUF_LEN, LOCAL_NETWORKID, strlen(LOCAL_NETWORKID));
253 EXPECT_EQ(SoftbusDumpPrintNetCapacity(fd, &nodeInfo), SOFTBUS_OK);
254 }
255
256 /*
257 * @tc.name: SOFTBUS_DUMP_PRINT_NET_TYPE_Test_001
258 * @tc.desc: SoftbusDumpPrintNetType test
259 * @tc.type: FUNC
260 * @tc.require:
261 */
262 HWTEST_F(LedgerLaneHubTest, SOFTBUS_DUMP_PRINT_NET_TYPE_Test_001, TestSize.Level1)
263 {
264 int fd = 0;
265 NodeBasicInfo nodeInfo;
266
267 (void)memset_s(&nodeInfo, sizeof(NodeBasicInfo), 0, sizeof(NodeBasicInfo));
268 (void)strncpy_s(nodeInfo.networkId, NETWORK_ID_BUF_LEN, NODE5_NETWORK_ID, strlen(NODE5_NETWORK_ID));
269 EXPECT_NE(SoftbusDumpPrintNetType(fd, &nodeInfo), SOFTBUS_OK);
270
271 ConstructCommonLocalInfo();
272 ConstructWiFiLocalInfo(true);
273
274 (void)memset_s(&nodeInfo, sizeof(NodeBasicInfo), 0, sizeof(NodeBasicInfo));
275 (void)strncpy_s(nodeInfo.networkId, NETWORK_ID_BUF_LEN, LOCAL_NETWORKID, strlen(LOCAL_NETWORKID));
276 EXPECT_EQ(SoftbusDumpPrintNetType(fd, &nodeInfo), SOFTBUS_OK);
277 }
278
279 /*
280 * @tc.name: LNN_SET_NODE_DATA_CHANGE_FLAG_Test_001
281 * @tc.desc: Lnn Set Node Data Change Flag test
282 * @tc.type: FUNC
283 * @tc.require:
284 */
285 HWTEST_F(LedgerLaneHubTest, LNN_SET_NODE_DATA_CHANGE_FLAG_Test_001, TestSize.Level1)
286 {
287 char *networkId = nullptr;
288 char networkIdSecond[NETWORK_ID_BUF_LEN] = "1234";
289 uint16_t dataChangeFlag = 0;
290 EXPECT_EQ(LnnSetNodeDataChangeFlag(networkId, dataChangeFlag), SOFTBUS_INVALID_PARAM);
291 EXPECT_EQ(LnnSetNodeDataChangeFlag(networkIdSecond, dataChangeFlag), SOFTBUS_ERR);
292
293 ConstructCommonLocalInfo();
294 EXPECT_EQ(LnnSetNodeDataChangeFlag(LOCAL_NETWORKID, dataChangeFlag), SOFTBUS_OK);
295 }
296
297 /*
298 * @tc.name: LNN_SET_DATA_CHANGE_FLAG_Test_001
299 * @tc.desc: Lnn Set Data Change Flag test
300 * @tc.type: FUNC
301 * @tc.require:
302 */
303 HWTEST_F(LedgerLaneHubTest, LNN_SET_DATA_CHANGE_FLAG_Test_001, TestSize.Level1)
304 {
305 NodeInfo info;
306 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
307 NodeInfo *nodeinfo = nullptr;
308 uint16_t dataChangeFlag = 0;
309 EXPECT_TRUE(LnnSetDataChangeFlag(nodeinfo, dataChangeFlag) == SOFTBUS_INVALID_PARAM);
310 nodeinfo = &info;
311 EXPECT_TRUE(LnnSetDataChangeFlag(nodeinfo, dataChangeFlag) == SOFTBUS_OK);
312 }
313
314 /*
315 * @tc.name: LNN_GET_DATA_CHANGE_FLAG_Test_001
316 * @tc.desc: Lnn Get Data Change Flag test
317 * @tc.type: FUNC
318 * @tc.require:
319 */
320 HWTEST_F(LedgerLaneHubTest, LNN_GET_DATA_CHANGE_FLAG_Test_001, TestSize.Level1)
321 {
322 NodeInfo info;
323 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
324 NodeInfo *nodeinfo = nullptr;
325 EXPECT_TRUE(LnnGetDataChangeFlag(nodeinfo) == 0);
326 nodeinfo = &info;
327 EXPECT_TRUE(LnnGetDataChangeFlag(nodeinfo) == 0);
328 }
329
330 /*
331 * @tc.name: LNN_GET_LOCAL_STR_INFO_Test_001
332 * @tc.desc: Lnn Get Local Str Info test
333 * @tc.type: FUNC
334 * @tc.require:
335 */
336 HWTEST_F(LedgerLaneHubTest, LNN_GET_LOCAL_STR_INFO_Test_001, TestSize.Level1)
337 {
338 NodeInfo info;
339 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
340 char *nodeInfo = reinterpret_cast<char*>(&info);
341 uint32_t len = 0;
342 EXPECT_TRUE(LnnSetLocalStrInfo(NUM_KEY_DATA_CHANGE_FLAG, nodeInfo) == SOFTBUS_INVALID_PARAM);
343 EXPECT_TRUE(LnnGetLocalStrInfo(NUM_KEY_AUTH_PORT, nodeInfo, len) == SOFTBUS_INVALID_PARAM);
344 EXPECT_TRUE(LnnGetLocalStrInfo(NUM_KEY_SESSION_PORT, nodeInfo, len) == SOFTBUS_INVALID_PARAM);
345 EXPECT_TRUE(LnnGetLocalStrInfo(NUM_KEY_PROXY_PORT, nodeInfo, len) == SOFTBUS_INVALID_PARAM);
346 EXPECT_TRUE(LnnGetLocalStrInfo(NUM_KEY_NET_CAP, nodeInfo, len) == SOFTBUS_INVALID_PARAM);
347 EXPECT_TRUE(LnnGetLocalStrInfo(NUM_KEY_DISCOVERY_TYPE, nodeInfo, len) == SOFTBUS_INVALID_PARAM);
348 EXPECT_TRUE(LnnGetLocalStrInfo(NUM_KEY_DEV_TYPE_ID, nodeInfo, len) == SOFTBUS_INVALID_PARAM);
349 EXPECT_TRUE(LnnGetLocalStrInfo(NUM_KEY_MASTER_NODE_WEIGHT, nodeInfo, len) == SOFTBUS_INVALID_PARAM);
350 EXPECT_TRUE(LnnGetLocalStrInfo(NUM_KEY_P2P_ROLE, nodeInfo, len) == SOFTBUS_INVALID_PARAM);
351 EXPECT_TRUE(LnnGetLocalStrInfo(NUM_KEY_DATA_CHANGE_FLAG, nodeInfo, len) == SOFTBUS_INVALID_PARAM);
352 }
353
354 /*
355 * @tc.name: LNN_INIT_LOCAL_LEDGER_DELAY_Test_001
356 * @tc.desc: Lnn Init Local Ledger Delay test
357 * @tc.type: FUNC
358 * @tc.require:
359 */
360 HWTEST_F(LedgerLaneHubTest, LNN_INIT_LOCAL_LEDGER_DELAY_Test_001, TestSize.Level1)
361 {
362 EXPECT_TRUE(LnnInitLocalLedgerDelay() == SOFTBUS_OK);
363 }
364
365 /*
366 * @tc.name: LEDGER_GetDistributedLedgerNode_Test_001
367 * @tc.desc: Get distributed ledger node info.
368 * @tc.type: FUNC
369 * @tc.require: AR000FK6J0
370 */
371 HWTEST_F(LedgerLaneHubTest, LEDGER_GetDistributedLedgerNode_Test_001, TestSize.Level1)
372 {
373 ConstructBRNode();
374 ConstructWlan2P4GNode();
375 LnnAddOnlineNode(&g_nodeInfo[BR_NUM]);
376 LnnAddOnlineNode(&g_nodeInfo[WLAN2P4G_NUM]);
377 LnnRemoveNode(NODE1_UDID);
378 LnnRemoveNode(NODE2_UDID);
379 }
380
381 /*
382 * @tc.name: LEDGER_GetDistributedLedgerInfo_Test_001
383 * @tc.desc: test of the LnnGetRemoteStrInfo LnnGetDLNumInfo function
384 * @tc.type: FUNC
385 * @tc.require: AR000FK6J0
386 */
387 HWTEST_F(LedgerLaneHubTest, LEDGER_GetDistributedLedgerInfo_Test_001, TestSize.Level1)
388 {
389 char deviceName[DEVICE_NAME_BUF_LEN] = {0};
390 char macAddr[MAC_LEN] = {0};
391 int32_t ret;
392 uint32_t cap = 0;
393 ConstructBRNode();
394 LnnAddOnlineNode(&g_nodeInfo[BR_NUM]);
395
396 // STRING_KEY_DEV_NAME
397 ret = LnnGetRemoteStrInfo(NODE1_NETWORK_ID, STRING_KEY_DEV_NAME, deviceName, DEVICE_NAME_BUF_LEN);
398 EXPECT_TRUE(ret == SOFTBUS_OK);
399 EXPECT_TRUE(strcmp(deviceName, NODE1_DEVICE_NAME) == 0);
400
401 // STRING_KEY_BT_MAC
402 ret = LnnGetRemoteStrInfo(NODE1_NETWORK_ID, STRING_KEY_BT_MAC, macAddr, MAC_LEN);
403 EXPECT_TRUE(ret == SOFTBUS_OK);
404 EXPECT_TRUE(strcmp(macAddr, NODE1_BT_MAC) == 0);
405
406 // NUM_KEY_NET_CAP
407 ret = LnnGetRemoteNumU32Info(NODE1_NETWORK_ID, NUM_KEY_NET_CAP, &cap);
408 EXPECT_TRUE(ret == SOFTBUS_OK);
409 EXPECT_TRUE((cap & (1 << BIT_BR)) != 0);
410
411 LnnRemoveNode(NODE1_UDID);
412 }
413
414 /*
415 * @tc.name: LEDGER_DistributedLedgerChangeName_Test_001
416 * @tc.desc: test of the LnnGetRemoteStrInfo LnnSetDLDeviceInfoName function
417 * @tc.type: FUNC
418 * @tc.require: AR000FK6J0
419 */
420 HWTEST_F(LedgerLaneHubTest, LEDGER_DistributedLedgerChangeName_Test_001, TestSize.Level1)
421 {
422 char deviceName[DEVICE_NAME_BUF_LEN] = {0};
423 ConstructWlan2P4GNode();
424 LnnAddOnlineNode(&g_nodeInfo[WLAN2P4G_NUM]);
425
426 // change name
427 bool result = LnnSetDLDeviceInfoName(NODE2_UDID, CHANGE_DEVICE_NAME);
428 EXPECT_TRUE(result);
429 // STRING_KEY_DEV_NAME
430 int ret = LnnGetRemoteStrInfo(NODE2_NETWORK_ID, STRING_KEY_DEV_NAME, deviceName, DEVICE_NAME_BUF_LEN);
431 EXPECT_TRUE(ret == SOFTBUS_OK);
432 EXPECT_TRUE(strcmp(deviceName, CHANGE_DEVICE_NAME) == 0);
433 LnnRemoveNode(NODE2_UDID);
434 }
435
436 /*
437 * @tc.name: LEDGER_LocalLedgerGetInfo_Test_001
438 * @tc.desc: Performance test of the LnnGetLocalLedgerStrInfo and NumInfo function.
439 * @tc.type: FUNC
440 * @tc.require: AR000FK6J0
441 */
442 HWTEST_F(LedgerLaneHubTest, LEDGER_LocalLedgerGetInfo_Test_001, TestSize.Level1)
443 {
444 char des[LOCAL_MAX_SIZE] = {0};
445 int32_t ret;
446 ConstructCommonLocalInfo();
447 ConstructBtLocalInfo();
448 ConstructWiFiLocalInfo(false);
449 GetCommonLocalInfo();
450 GetBTLocalInfo();
451 GetWiFiLocalInfo();
452
453 // change devicename
454 ret = LnnSetLocalStrInfo(STRING_KEY_DEV_NAME, LOCAL_CHANAGE_DEVNAME);
455 EXPECT_TRUE(ret == SOFTBUS_OK);
456 ret = LnnGetLocalStrInfo(STRING_KEY_DEV_NAME, des, LOCAL_MAX_SIZE);
457 EXPECT_TRUE((ret == SOFTBUS_OK) && (strcmp(des, LOCAL_CHANAGE_DEVNAME) == 0));
458 }
459 } // namespace OHOS
460