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 <cstdint>
18 #include <cstdlib>
19 #include <cstring>
20 #include <gtest/gtest.h>
21 #include <securec.h>
22
23 #include "bus_center_manager.h"
24 #include "lnn_decision_db.h"
25 #include "lnn_device_info.h"
26 #include "lnn_distributed_net_ledger.h"
27 #include "lnn_feature_capability.h"
28 #include "lnn_huks_utils.h"
29 #include "lnn_local_net_ledger.h"
30 #include "lnn_log.h"
31 #include "lnn_meta_node_ledger.h"
32 #include "lnn_net_capability.h"
33 #include "lnn_net_ledger.h"
34 #include "lnn_net_ledger_common_mock.h"
35 #include "lnn_node_info.h"
36 #include "lnn_oobe_manager.h"
37 #include "softbus_adapter_mem.h"
38 #include "softbus_error_code.h"
39 #include "softbus_feature_config.h"
40 #include "softbus_utils.h"
41
42 #define ONE_BIT_MAX_HEX 15
43 #define DEVICE_TYPE_MAX_LENGTH 3
44 #define LEFT_SHIFT_DEVICE_TYPE_LENGTH (DEVICE_TYPE_MAX_LENGTH * 4)
45 #define DEFAUTL_LNN_FEATURE 0x3E2
46
47 namespace OHOS {
48 using namespace testing::ext;
49 constexpr char NODE_DEVICE_NAME[] = "node1_test";
50 constexpr char INVALID_DEVICE_NAME[] = "ASDFGHJKLPASDFGHJKLPASDFGHJKLPASDFGHJKLPASDFGHJKLPASDFGHJKLPASDFGHJKLPASDFGHJK\
51 LPASDFGHJKLPASDFGHJKLPASDFGHJKLPASDFGHJKLPASDFGHJKLPASDFGHJKLPASDFGHJKLPASDFGHJ\
52 KLPASDFGHJKLPASDFGHJKLPASDFGHJKLPASDFGHJKLP";
53 constexpr char DEVICE_TYPE[] = "PAD";
54 constexpr char INVALID_DEVICE_TYPE[] = "PADPAD";
55 constexpr int32_t PORT = 1;
56 constexpr uint64_t PROTOCOLS = 1;
57 constexpr char LOCAL_NETWORKID[] = "123456LOCAL";
58 constexpr char REMOTE_NETWORKID[] = "234567REMOTE";
59 constexpr uint32_t BUF_LEN = 128;
60 constexpr int32_t KEY_MAX_INDEX = 11;
61 constexpr uint16_t DATA_CHANGE_FLAG = 1;
62 constexpr char LOCAL_UDID[] = "123456LOCALTEST";
63 constexpr char LOCAL_UUID[] = "235999LOCAL";
64 constexpr char LOCAL_BT_MAC[] = "56789TUT";
65 constexpr char LOCAL_WLAN_IP[] = "10.146.181.134";
66 constexpr int32_t DEFAULT_FD = 1;
67 constexpr char LOCAL_DEVTYPE[] = "TYPE_WATCH";
68 constexpr char LOCAL_NET_IF_NAME[] = "LOCAL";
69 constexpr char MASTER_NODE_UDID[] = "234567LOCALTEST";
70 constexpr char LOCAL_NODE_ADDR[] = "ADDR";
71 constexpr char LOCAL_P2P_MAC[] = "11:22:33:44:55";
72 constexpr char LOCAL_GO_MAC[] = "22:33:44:55:66";
73 constexpr char LOCAL_WIFIDIRECT_ADDR[] = "55:66:77:88:99";
74 constexpr uint32_t LOCAL_SESSION_PORT = 5000;
75 constexpr uint32_t LOCAL_AUTH_PORT = 6000;
76 constexpr uint32_t LOCAL_PROXY_PORT = 7000;
77 constexpr uint32_t LOCAL_CAPACITY = 3;
78 constexpr int32_t MASTER_WEIGHT = 10;
79 constexpr int32_t P2P_ROLE = 1;
80 constexpr int32_t STATIC_LEN = 10;
81 using namespace testing;
82 class LNNNetLedgerCommonTest : public testing::Test {
83 public:
84 static void SetUpTestCase();
85 static void TearDownTestCase();
86 void SetUp();
87 void TearDown();
88 };
89
SetUpTestCase()90 void LNNNetLedgerCommonTest::SetUpTestCase() { }
91
TearDownTestCase()92 void LNNNetLedgerCommonTest::TearDownTestCase() { }
93
SetUp()94 void LNNNetLedgerCommonTest::SetUp()
95 {
96 LNN_LOGI(LNN_TEST, "LNNNetLedgerCommonTest start");
97 }
98
TearDown()99 void LNNNetLedgerCommonTest::TearDown() { }
100
101 /*
102 * @tc.name: LNN_DEVICE_INFO_Test_001
103 * @tc.desc: lnn device info function test
104 * @tc.type: FUNC
105 * @tc.require:
106 */
107 HWTEST_F(LNNNetLedgerCommonTest, LNN_DEVICE_INFO_Test_001, TestSize.Level1)
108 {
109 DeviceBasicInfo info;
110 uint16_t typeId = 0;
111 int32_t ret = memset_s(&info, sizeof(DeviceBasicInfo), 0, sizeof(DeviceBasicInfo));
112 EXPECT_TRUE(ret == EOK);
113 EXPECT_TRUE(LnnGetDeviceName(nullptr) == nullptr);
114 LnnGetDeviceName(&info);
115 EXPECT_TRUE(LnnSetDeviceName(nullptr, NODE_DEVICE_NAME) == SOFTBUS_INVALID_PARAM);
116 EXPECT_TRUE(LnnSetDeviceName(&info, nullptr) == SOFTBUS_INVALID_PARAM);
117 EXPECT_TRUE(LnnSetDeviceName(&info, INVALID_DEVICE_NAME) == SOFTBUS_INVALID_PARAM);
118 EXPECT_TRUE(LnnSetDeviceName(&info, NODE_DEVICE_NAME) == SOFTBUS_OK);
119 EXPECT_TRUE(LnnGetDeviceTypeId(nullptr, &typeId) == SOFTBUS_INVALID_PARAM);
120 EXPECT_TRUE(LnnGetDeviceTypeId(&info, nullptr) == SOFTBUS_INVALID_PARAM);
121 EXPECT_TRUE(LnnGetDeviceTypeId(&info, &typeId) == SOFTBUS_OK);
122 EXPECT_TRUE(LnnConvertDeviceTypeToId(nullptr, nullptr) == SOFTBUS_INVALID_PARAM);
123 EXPECT_TRUE(LnnConvertDeviceTypeToId(INVALID_DEVICE_TYPE, &typeId) == SOFTBUS_NETWORK_INVALID_DEV_INFO);
124 EXPECT_TRUE(LnnConvertDeviceTypeToId(DEVICE_TYPE, &typeId) == SOFTBUS_OK);
125 typeId = 0;
126 LnnConvertIdToDeviceType(TYPE_WATCH_ID);
127 LnnConvertIdToDeviceType(typeId);
128 typeId = ONE_BIT_MAX_HEX << LEFT_SHIFT_DEVICE_TYPE_LENGTH;
129 EXPECT_TRUE(LnnConvertIdToDeviceType(typeId) != nullptr);
130 }
131
132 /*
133 * @tc.name: LNN_HUKS_UTILS_Test_001
134 * @tc.desc: lnn huks utils function test
135 * @tc.type: FUNC
136 * @tc.require:
137 */
138 HWTEST_F(LNNNetLedgerCommonTest, LNN_HUKS_UTILS_Test_001, TestSize.Level1)
139 {
140 struct HksBlob keyAlias;
141 (void)memset_s(&keyAlias, sizeof(HksBlob), 0, sizeof(HksBlob));
142 EXPECT_TRUE(LnnGenerateKeyByHuks(nullptr) == SOFTBUS_INVALID_PARAM);
143 EXPECT_TRUE(LnnGenerateKeyByHuks(&keyAlias) == SOFTBUS_HUKS_GENERATE_KEY_ERR);
144 EXPECT_TRUE(LnnDeleteKeyByHuks(nullptr) == SOFTBUS_INVALID_PARAM);
145 EXPECT_TRUE(LnnDeleteKeyByHuks(&keyAlias) == SOFTBUS_OK);
146 EXPECT_TRUE(LnnEncryptDataByHuks(nullptr, nullptr, nullptr) == SOFTBUS_INVALID_PARAM);
147 EXPECT_TRUE(LnnDecryptDataByHuks(nullptr, nullptr, nullptr) == SOFTBUS_INVALID_PARAM);
148 }
149
150 /*
151 * @tc.name: LNN_NET_CAPABILITY_Test_001
152 * @tc.desc: lnn net capability function test
153 * @tc.type: FUNC
154 * @tc.require:
155 */
156 HWTEST_F(LNNNetLedgerCommonTest, LNN_NET_CAPABILITY_Test_001, TestSize.Level1)
157 {
158 uint32_t capability = 0;
159 EXPECT_TRUE(LnnSetNetCapability(nullptr, BIT_COUNT) == SOFTBUS_INVALID_PARAM);
160 EXPECT_TRUE(LnnClearNetCapability(nullptr, BIT_COUNT) == SOFTBUS_INVALID_PARAM);
161 EXPECT_TRUE(LnnClearNetCapability(&capability, BIT_BLE) == SOFTBUS_OK);
162 }
163
164 /*
165 * @tc.name: LNN_NET_CAPABILITY_Test_002
166 * @tc.desc: lnn net capability function test, LnnSetNetCapability, LnnHasCapability
167 * @tc.type: FUNC
168 * @tc.require:
169 */
170 HWTEST_F(LNNNetLedgerCommonTest, LNN_NET_CAPABILITY_Test_002, TestSize.Level1)
171 {
172 uint32_t capability = 0;
173 bool hasCapability = false;
174 int32_t ret = LnnSetNetCapability(&capability, BIT_BLE);
175 EXPECT_EQ(ret, SOFTBUS_OK);
176 hasCapability = LnnHasCapability(capability, BIT_BLE);
177 EXPECT_EQ(hasCapability, true);
178
179 ret = LnnSetNetCapability(&capability, BIT_BR);
180 EXPECT_EQ(ret, SOFTBUS_OK);
181 hasCapability = LnnHasCapability(capability, BIT_BR);
182 EXPECT_EQ(hasCapability, true);
183
184 ret = LnnSetNetCapability(&capability, BIT_WIFI);
185 EXPECT_EQ(ret, SOFTBUS_OK);
186 hasCapability = LnnHasCapability(capability, BIT_WIFI);
187 EXPECT_EQ(hasCapability, true);
188
189 ret = LnnSetNetCapability(&capability, BIT_WIFI_P2P);
190 EXPECT_EQ(ret, SOFTBUS_OK);
191 hasCapability = LnnHasCapability(capability, BIT_WIFI_P2P);
192 EXPECT_EQ(hasCapability, true);
193
194 ret = LnnSetNetCapability(&capability, BIT_WIFI_24G);
195 EXPECT_EQ(ret, SOFTBUS_OK);
196 hasCapability = LnnHasCapability(capability, BIT_WIFI_24G);
197 EXPECT_EQ(hasCapability, true);
198
199 ret = LnnSetNetCapability(&capability, BIT_WIFI_5G);
200 EXPECT_EQ(ret, SOFTBUS_OK);
201 hasCapability = LnnHasCapability(capability, BIT_WIFI_5G);
202 EXPECT_EQ(hasCapability, true);
203
204 ret = LnnSetNetCapability(&capability, BIT_ETH);
205 EXPECT_EQ(ret, SOFTBUS_OK);
206 hasCapability = LnnHasCapability(capability, BIT_ETH);
207 EXPECT_EQ(hasCapability, true);
208 }
209
210 /*
211 * @tc.name: LNN_NET_CAPABILITY_Test_003
212 * @tc.desc: lnn net capability function test, LnnSetNetCapability, LnnClearNetCapability
213 * @tc.type: FUNC
214 * @tc.require:
215 */
216 HWTEST_F(LNNNetLedgerCommonTest, LNN_NET_CAPABILITY_Test_003, TestSize.Level1)
217 {
218 uint32_t capability = 0;
219 bool hasCapability = false;
220 int32_t ret = LnnSetNetCapability(&capability, BIT_BLE);
221 EXPECT_EQ(ret, SOFTBUS_OK);
222 hasCapability = LnnHasCapability(capability, BIT_BLE);
223 EXPECT_EQ(hasCapability, true);
224
225 ret = LnnClearNetCapability(&capability, BIT_BLE);
226 EXPECT_EQ(ret, SOFTBUS_OK);
227 hasCapability = LnnHasCapability(capability, BIT_BLE);
228 EXPECT_EQ(hasCapability, false);
229
230 ret = LnnSetNetCapability(&capability, BIT_COUNT);
231 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
232 hasCapability = LnnHasCapability(capability, BIT_COUNT);
233 EXPECT_EQ(hasCapability, false);
234 ret = LnnClearNetCapability(&capability, BIT_COUNT);
235 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
236 }
237
238 /*
239 * @tc.name: LNN_NODE_INFO_Test_001
240 * @tc.desc: lnn node info function test
241 * @tc.type: FUNC
242 * @tc.require:
243 */
244 HWTEST_F(LNNNetLedgerCommonTest, LNN_NODE_INFO_Test_001, TestSize.Level1)
245 {
246 EXPECT_TRUE(LnnHasDiscoveryType(nullptr, DISCOVERY_TYPE_WIFI) == false);
247 EXPECT_TRUE(LnnGetDeviceUdid(nullptr) == nullptr);
248 EXPECT_TRUE(LnnSetDeviceUdid(nullptr, nullptr) == SOFTBUS_INVALID_PARAM);
249 EXPECT_TRUE(LnnSetDiscoveryType(nullptr, DISCOVERY_TYPE_WIFI) == SOFTBUS_INVALID_PARAM);
250 EXPECT_TRUE(LnnClearDiscoveryType(nullptr, DISCOVERY_TYPE_WIFI) == SOFTBUS_INVALID_PARAM);
251 EXPECT_TRUE(LnnIsNodeOnline(nullptr) == false);
252 LnnSetNodeConnStatus(nullptr, STATUS_ONLINE);
253 LnnGetBtMac(nullptr);
254 LnnSetBtMac(nullptr, nullptr);
255 LnnGetNetIfName(nullptr);
256 LnnSetNetIfName(nullptr, nullptr);
257 LnnGetWiFiIp(nullptr);
258 LnnSetWiFiIp(nullptr, nullptr);
259 EXPECT_TRUE(LnnGetMasterUdid(nullptr) == nullptr);
260 EXPECT_TRUE(LnnSetMasterUdid(nullptr, nullptr) == SOFTBUS_INVALID_PARAM);
261 EXPECT_TRUE(LnnGetAuthPort(nullptr) == SOFTBUS_INVALID_PARAM);
262 EXPECT_TRUE(LnnSetAuthPort(nullptr, PORT) == SOFTBUS_INVALID_PARAM);
263 EXPECT_TRUE(LnnGetSessionPort(nullptr) == SOFTBUS_INVALID_PARAM);
264 EXPECT_TRUE(LnnSetSessionPort(nullptr, PORT) == SOFTBUS_INVALID_PARAM);
265 EXPECT_TRUE(LnnGetProxyPort(nullptr) == SOFTBUS_INVALID_PARAM);
266 EXPECT_TRUE(LnnSetProxyPort(nullptr, PORT) == SOFTBUS_INVALID_PARAM);
267 EXPECT_TRUE(LnnSetP2pRole(nullptr, PORT) == SOFTBUS_INVALID_PARAM);
268 EXPECT_TRUE(LnnGetP2pRole(nullptr) == 0);
269 EXPECT_TRUE(LnnSetP2pMac(nullptr, nullptr) == SOFTBUS_INVALID_PARAM);
270 EXPECT_TRUE(LnnGetP2pMac(nullptr) == nullptr);
271 EXPECT_TRUE(LnnSetP2pGoMac(nullptr, nullptr) == SOFTBUS_INVALID_PARAM);
272 EXPECT_TRUE(LnnGetWifiDirectAddr(nullptr) == nullptr);
273 EXPECT_TRUE(LnnSetWifiDirectAddr(nullptr, nullptr) == SOFTBUS_INVALID_PARAM);
274 EXPECT_TRUE(LnnGetP2pGoMac(nullptr) == nullptr);
275 EXPECT_TRUE(LnnGetSupportedProtocols(nullptr) == 0);
276 EXPECT_TRUE(LnnSetSupportedProtocols(nullptr, PROTOCOLS) == SOFTBUS_INVALID_PARAM);
277 EXPECT_TRUE(LnnSetStaticCapability(nullptr, nullptr, 0) == SOFTBUS_INVALID_PARAM);
278 EXPECT_TRUE(LnnGetStaticCapability(nullptr, nullptr, 0) == SOFTBUS_INVALID_PARAM);
279 EXPECT_TRUE(LnnSetPtk(nullptr, nullptr) == SOFTBUS_INVALID_PARAM);
280 }
281
282 /*
283 * @tc.name: LNN_NODE_INFO_Test_002
284 * @tc.desc: lnn node info function test, LnnSetDiscoveryType, LnnHasDiscoveryType, LnnClearDiscoveryType
285 * @tc.type: FUNC
286 * @tc.require:
287 */
288 HWTEST_F(LNNNetLedgerCommonTest, LNN_NODE_INFO_Test_002, TestSize.Level1)
289 {
290 NodeInfo nodeInfo;
291 int32_t ret = LnnSetDiscoveryType(&nodeInfo, DISCOVERY_TYPE_COUNT);
292 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
293 ret = LnnSetDiscoveryType(nullptr, DISCOVERY_TYPE_UNKNOWN);
294 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
295 ret = LnnSetDiscoveryType(&nodeInfo, DISCOVERY_TYPE_LSA);
296 EXPECT_EQ(ret, SOFTBUS_OK);
297
298 bool hasDiscoveryType = LnnHasDiscoveryType(nullptr, DISCOVERY_TYPE_LSA);
299 EXPECT_EQ(hasDiscoveryType, false);
300 hasDiscoveryType = LnnHasDiscoveryType(&nodeInfo, DISCOVERY_TYPE_COUNT);
301 EXPECT_EQ(hasDiscoveryType, false);
302 hasDiscoveryType = LnnHasDiscoveryType(&nodeInfo, DISCOVERY_TYPE_UNKNOWN);
303 EXPECT_EQ(hasDiscoveryType, false);
304 hasDiscoveryType = LnnHasDiscoveryType(&nodeInfo, DISCOVERY_TYPE_LSA);
305 EXPECT_EQ(hasDiscoveryType, true);
306
307 ret = LnnClearDiscoveryType(nullptr, DISCOVERY_TYPE_UNKNOWN);
308 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
309 ret = LnnClearDiscoveryType(&nodeInfo, DISCOVERY_TYPE_COUNT);
310 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
311 ret = LnnClearDiscoveryType(&nodeInfo, DISCOVERY_TYPE_LSA);
312 EXPECT_EQ(ret, SOFTBUS_OK);
313
314 hasDiscoveryType = LnnHasDiscoveryType(&nodeInfo, DISCOVERY_TYPE_LSA);
315 EXPECT_EQ(hasDiscoveryType, false);
316 ret = LnnClearDiscoveryType(&nodeInfo, DISCOVERY_TYPE_UNKNOWN);
317 EXPECT_EQ(ret, SOFTBUS_OK);
318 hasDiscoveryType = LnnHasDiscoveryType(&nodeInfo, DISCOVERY_TYPE_UNKNOWN);
319 EXPECT_EQ(hasDiscoveryType, false);
320 }
321
322 /*
323 * @tc.name: LNN_NODE_INFO_Test_003
324 * @tc.desc: lnn node info function test, LnnSetDeviceUdid, LnnGetDeviceUdid
325 * @tc.type: FUNC
326 * @tc.require:
327 */
328 HWTEST_F(LNNNetLedgerCommonTest, LNN_NODE_INFO_Test_003, TestSize.Level1)
329 {
330 NodeInfo nodeInfo;
331 int32_t ret = LnnSetDeviceUdid(&nodeInfo, nullptr);
332 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
333 ret = LnnSetDeviceUdid(nullptr, LOCAL_UDID);
334 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
335
336 char *udid = (char *)SoftBusCalloc((UDID_BUF_LEN + 1) * sizeof(char));
337 ret = LnnSetDeviceUdid(&nodeInfo, udid);
338 EXPECT_EQ(ret, SOFTBUS_OK);
339 SoftBusFree(udid);
340
341 ret = LnnSetDeviceUdid(&nodeInfo, LOCAL_UDID);
342 EXPECT_EQ(ret, SOFTBUS_OK);
343 EXPECT_EQ(strcmp(nodeInfo.deviceInfo.deviceUdid, LOCAL_UDID), 0);
344
345 const char *deviceUdid = LnnGetDeviceUdid(nullptr);
346 EXPECT_EQ(deviceUdid, nullptr);
347 deviceUdid = LnnGetDeviceUdid(&nodeInfo);
348 EXPECT_EQ(strcmp(deviceUdid, LOCAL_UDID), 0);
349 }
350
351 /*
352 * @tc.name: LNN_NODE_INFO_Test_004
353 * @tc.desc: lnn node info function test, LnnGetDeviceUuid
354 * @tc.type: FUNC
355 * @tc.require:
356 */
357 HWTEST_F(LNNNetLedgerCommonTest, LNN_NODE_INFO_Test_004, TestSize.Level1)
358 {
359 NodeInfo nodeInfo;
360 int32_t ret = strncpy_s(nodeInfo.uuid, UUID_BUF_LEN, LOCAL_UUID, strlen(LOCAL_UUID));
361 EXPECT_EQ(ret, EOK);
362
363 const char *uuid = LnnGetDeviceUuid(nullptr);
364 EXPECT_EQ(uuid, nullptr);
365 uuid = LnnGetDeviceUuid(&nodeInfo);
366 EXPECT_EQ(strcmp(uuid, LOCAL_UUID), 0);
367 }
368
369 /*
370 * @tc.name: LNN_NODE_INFO_Test_005
371 * @tc.desc: lnn node info function testm, LnnSetBtMac, LnnGetBtMac
372 * @tc.type: FUNC
373 * @tc.require:
374 */
375 HWTEST_F(LNNNetLedgerCommonTest, LNN_NODE_INFO_Test_005, TestSize.Level1)
376 {
377 NodeInfo nodeInfo;
378
379 LnnSetBtMac(nullptr, LOCAL_BT_MAC);
380 EXPECT_NE(strcmp(nodeInfo.connectInfo.macAddr, LOCAL_BT_MAC), 0);
381
382 LnnSetBtMac(&nodeInfo, nullptr);
383 EXPECT_NE(strcmp(nodeInfo.connectInfo.macAddr, LOCAL_BT_MAC), 0);
384
385 LnnSetBtMac(&nodeInfo, LOCAL_BT_MAC);
386 EXPECT_EQ(strcmp(nodeInfo.connectInfo.macAddr, LOCAL_BT_MAC), 0);
387
388 const char *btMac = nullptr;
389 btMac = LnnGetBtMac(&nodeInfo);
390 EXPECT_EQ(strcmp(btMac, LOCAL_BT_MAC), 0);
391
392 char *localBtMac = (char *)SoftBusCalloc((MAC_LEN + 1) * sizeof(char));
393 LnnSetBtMac(&nodeInfo, localBtMac);
394 EXPECT_EQ(strcmp(nodeInfo.connectInfo.macAddr, localBtMac), 0);
395 SoftBusFree(localBtMac);
396
397 btMac = LnnGetBtMac(nullptr);
398 EXPECT_EQ(strcmp(btMac, DEFAULT_MAC), 0);
399 }
400
401 /*
402 * @tc.name: LNN_NODE_INFO_Test_006
403 * @tc.desc: lnn node info function test, LnnSetNetIfName, LnnGetNetIfName
404 * @tc.type: FUNC
405 * @tc.require:
406 */
407 HWTEST_F(LNNNetLedgerCommonTest, LNN_NODE_INFO_Test_006, TestSize.Level1)
408 {
409 NodeInfo nodeInfo;
410 constexpr char netIfName1[] = "wlan0";
411
412 LnnSetNetIfName(nullptr, netIfName1);
413 EXPECT_NE(strcmp(nodeInfo.connectInfo.netIfName, netIfName1), 0);
414
415 LnnSetNetIfName(&nodeInfo, nullptr);
416 EXPECT_NE(strcmp(nodeInfo.connectInfo.netIfName, netIfName1), 0);
417
418 char *netIfName2 = (char *)SoftBusCalloc((NET_IF_NAME_LEN + 1) * sizeof(char));
419 LnnSetNetIfName(&nodeInfo, netIfName2);
420 SoftBusFree(netIfName2);
421
422 LnnSetNetIfName(&nodeInfo, netIfName1);
423 EXPECT_EQ(strcmp(nodeInfo.connectInfo.netIfName, netIfName1), 0);
424
425 const char *netIfName = nullptr;
426 netIfName = LnnGetNetIfName(&nodeInfo);
427 EXPECT_EQ(strcmp(netIfName, netIfName1), 0);
428
429 netIfName = LnnGetNetIfName(nullptr);
430 EXPECT_EQ(strcmp(netIfName, DEFAULT_IFNAME), 0);
431 }
432
433 /*
434 * @tc.name: LNN_NODE_INFO_Test_007
435 * @tc.desc: lnn node info function test, LnnSetWiFiIp
436 * @tc.type: FUNC
437 * @tc.require:
438 */
439 HWTEST_F(LNNNetLedgerCommonTest, LNN_NODE_INFO_Test_007, TestSize.Level1)
440 {
441 NodeInfo nodeInfo;
442
443 LnnSetWiFiIp(nullptr, LOCAL_WLAN_IP);
444 EXPECT_NE(strcmp(nodeInfo.connectInfo.deviceIp, LOCAL_WLAN_IP), 0);
445 LnnSetWiFiIp(&nodeInfo, LOCAL_WLAN_IP);
446 EXPECT_EQ(strcmp(nodeInfo.connectInfo.deviceIp, LOCAL_WLAN_IP), 0);
447 }
448
449 /*
450 * @tc.name: LNN_NODE_INFO_Test_008
451 * @tc.desc: lnn node info function test, LnnSetMasterUdid, LnnGetMasterUdid
452 * @tc.type: FUNC
453 * @tc.require:
454 */
455 HWTEST_F(LNNNetLedgerCommonTest, LNN_NODE_INFO_Test_008, TestSize.Level1)
456 {
457 NodeInfo nodeInfo;
458 int32_t ret = LnnSetMasterUdid(nullptr, MASTER_NODE_UDID);
459 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
460 ret = LnnSetMasterUdid(&nodeInfo, MASTER_NODE_UDID);
461 EXPECT_EQ(ret, SOFTBUS_OK);
462 const char *udid = LnnGetMasterUdid(nullptr);
463 EXPECT_EQ(udid, nullptr);
464 udid = LnnGetMasterUdid(&nodeInfo);
465 EXPECT_EQ(strcmp(udid, MASTER_NODE_UDID), 0);
466 }
467
468 /*
469 * @tc.name: LNN_NODE_INFO_Test_009
470 * @tc.desc: lnn node info function test, LnnSetWifiCfg, LnnGetWifiCfg
471 * @tc.type: FUNC
472 * @tc.require:
473 */
474 HWTEST_F(LNNNetLedgerCommonTest, LNN_NODE_INFO_Test_009, TestSize.Level1)
475 {
476 NodeInfo nodeInfo;
477 char wifiCfg1[] = "wifiCfg test msg";
478
479 int32_t ret = LnnSetWifiCfg(nullptr, wifiCfg1);
480 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
481
482 ret = LnnSetWifiCfg(&nodeInfo, nullptr);
483 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
484
485 char *wifiCfg2 = (char *)SoftBusCalloc((WIFI_CFG_INFO_MAX_LEN + 1) * sizeof(char));
486 ret = LnnSetWifiCfg(&nodeInfo, wifiCfg2);
487 EXPECT_EQ(ret, SOFTBUS_OK);
488 SoftBusFree(wifiCfg2);
489
490 ret = LnnSetWifiCfg(&nodeInfo, wifiCfg1);
491 EXPECT_EQ(ret, SOFTBUS_OK);
492 const char *wifiCfg = nullptr;
493 wifiCfg = LnnGetWifiCfg(&nodeInfo);
494 EXPECT_EQ(wifiCfg, nodeInfo.p2pInfo.wifiCfg);
495
496 wifiCfg = LnnGetWifiCfg(nullptr);
497 EXPECT_EQ(wifiCfg, nullptr);
498 }
499
500 /*
501 * @tc.name: LNN_NODE_INFO_Test_010
502 * @tc.desc: lnn node info function test, LnnSetChanList5g, LnnGetChanList5g
503 * @tc.type: FUNC
504 * @tc.require:
505 */
506 HWTEST_F(LNNNetLedgerCommonTest, LNN_NODE_INFO_Test_010, TestSize.Level1)
507 {
508 NodeInfo nodeInfo;
509 char chanList5g1[CHANNEL_LIST_STR_LEN];
510 int32_t ret = LnnSetChanList5g(nullptr, chanList5g1);
511 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
512
513 ret = LnnSetChanList5g(&nodeInfo, nullptr);
514 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
515
516 char *chanList5g2 = (char *)SoftBusCalloc((CHANNEL_LIST_STR_LEN + 1) * sizeof(char));
517 ret = LnnSetChanList5g(&nodeInfo, chanList5g2);
518 EXPECT_EQ(ret, SOFTBUS_OK);
519 SoftBusFree(chanList5g2);
520
521 ret = LnnSetChanList5g(&nodeInfo, chanList5g1);
522 EXPECT_EQ(ret, SOFTBUS_OK);
523 const char *chanList5g = nullptr;
524 chanList5g = LnnGetChanList5g(&nodeInfo);
525 EXPECT_EQ(chanList5g, nodeInfo.p2pInfo.chanList5g);
526
527 chanList5g = LnnGetChanList5g(nullptr);
528 EXPECT_EQ(chanList5g, nullptr);
529 }
530
531 /*
532 * @tc.name: LNN_NODE_INFO_Test_011
533 * @tc.desc: lnn node info function test LnnSetP2pGoMac, LnnGetP2pGoMac
534 * @tc.type: FUNC
535 * @tc.require:
536 */
537 HWTEST_F(LNNNetLedgerCommonTest, LNN_NODE_INFO_Test_011, TestSize.Level1)
538 {
539 NodeInfo nodeInfo;
540 int32_t ret;
541 const char *goMac = nullptr;
542
543 ret = LnnSetP2pGoMac(nullptr, LOCAL_GO_MAC);
544 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
545 goMac = LnnGetP2pGoMac(&nodeInfo);
546 EXPECT_NE(strcmp(goMac, LOCAL_GO_MAC), 0);
547
548 ret = LnnSetP2pGoMac(&nodeInfo, nullptr);
549 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
550 goMac = LnnGetP2pGoMac(&nodeInfo);
551 EXPECT_NE(strcmp(goMac, LOCAL_GO_MAC), 0);
552
553 ret = LnnSetP2pGoMac(&nodeInfo, LOCAL_GO_MAC);
554 EXPECT_EQ(ret, SOFTBUS_OK);
555 goMac = LnnGetP2pGoMac(&nodeInfo);
556 EXPECT_EQ(strcmp(goMac, LOCAL_GO_MAC), 0);
557 }
558
559 /*
560 * @tc.name: LNN_NODE_INFO_Test_012
561 * @tc.desc: lnn node info function test, LnnSetStaFrequency, LnnGetStaFrequency
562 * @tc.type: FUNC
563 * @tc.require:
564 */
565 HWTEST_F(LNNNetLedgerCommonTest, LNN_NODE_INFO_Test_012, TestSize.Level1)
566 {
567 NodeInfo nodeInfo;
568 int32_t staFrequency = 1;
569
570 int32_t ret = LnnSetStaFrequency(nullptr, staFrequency);
571 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
572
573 ret = LnnSetStaFrequency(&nodeInfo, staFrequency);
574 EXPECT_EQ(ret, SOFTBUS_OK);
575 int32_t rst = LnnGetStaFrequency(&nodeInfo);
576 EXPECT_EQ(rst, 1);
577
578 rst = LnnGetStaFrequency(nullptr);
579 EXPECT_EQ(rst, 0);
580 }
581
582 /*
583 * @tc.name: LNN_NODE_INFO_Test_013
584 * @tc.desc: lnn node info function test, LnnSetP2pMac, LnnGetP2pMac
585 * @tc.type: FUNC
586 * @tc.require:
587 */
588 HWTEST_F(LNNNetLedgerCommonTest, LNN_NODE_INFO_Test_013, TestSize.Level1)
589 {
590 NodeInfo nodeInfo;
591 const char *mac = nullptr;
592
593 int32_t ret = LnnSetP2pMac(nullptr, LOCAL_P2P_MAC);
594 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
595 ret = LnnSetP2pMac(&nodeInfo, nullptr);
596 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
597 ret = LnnSetP2pMac(&nodeInfo, LOCAL_P2P_MAC);
598 EXPECT_EQ(ret, SOFTBUS_OK);
599
600 mac = LnnGetP2pMac(nullptr);
601 EXPECT_EQ(mac, nullptr);
602 mac = LnnGetP2pMac(&nodeInfo);
603 EXPECT_EQ(strcmp(mac, LOCAL_P2P_MAC), 0);
604 }
605
606 /*
607 * @tc.name: LNN_NODE_INFO_Test_014
608 * @tc.desc: lnn node info function test, LnnSetDataDynamicLevel, LnnGetDataDynamicLevel
609 * @tc.type: FUNC
610 * @tc.require:
611 */
612 HWTEST_F(LNNNetLedgerCommonTest, LNN_NODE_INFO_Test_014, TestSize.Level1)
613 {
614 NodeInfo nodeInfo;
615 uint16_t dataDynamicLevel = 1;
616
617 int32_t ret = LnnSetDataDynamicLevel(nullptr, dataDynamicLevel);
618 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
619
620 ret = LnnSetDataDynamicLevel(&nodeInfo, dataDynamicLevel);
621 EXPECT_EQ(ret, SOFTBUS_OK);
622 uint16_t Level = LnnGetDataDynamicLevel(&nodeInfo);
623 EXPECT_EQ(Level, 1);
624
625 Level = LnnGetDataDynamicLevel(nullptr);
626 EXPECT_NE(Level, 1);
627 }
628
629 /*
630 * @tc.name: LNN_NODE_INFO_Test_015
631 * @tc.desc: lnn node info function test, LnnSetDataStaticLevel, LnnGetDataStaticLevel
632 * @tc.type: FUNC
633 * @tc.require:
634 */
635 HWTEST_F(LNNNetLedgerCommonTest, LNN_NODE_INFO_Test_015, TestSize.Level1)
636 {
637 NodeInfo nodeInfo;
638 uint16_t dataStaticLevel = 1;
639
640 int32_t ret = LnnSetDataStaticLevel(nullptr, dataStaticLevel);
641 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
642
643 ret = LnnSetDataStaticLevel(&nodeInfo, dataStaticLevel);
644 EXPECT_EQ(ret, SOFTBUS_OK);
645 uint16_t Level = LnnGetDataStaticLevel(&nodeInfo);
646 EXPECT_EQ(Level, 1);
647
648 Level = LnnGetDataStaticLevel(nullptr);
649 EXPECT_NE(Level, 1);
650 }
651
652 /*
653 * @tc.name: LNN_NODE_INFO_Test_016
654 * @tc.desc: lnn node info function test, LnnSetDataSwitchLevel, LnnGetDataSwitchLevel
655 * @tc.type: FUNC
656 * @tc.require:
657 */
658 HWTEST_F(LNNNetLedgerCommonTest, LNN_NODE_INFO_Test_016, TestSize.Level1)
659 {
660 NodeInfo nodeInfo;
661 uint32_t dataSwitchLevel = 1;
662
663 int32_t ret = LnnSetDataSwitchLevel(nullptr, dataSwitchLevel);
664 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
665
666 ret = LnnSetDataSwitchLevel(&nodeInfo, dataSwitchLevel);
667 EXPECT_EQ(ret, SOFTBUS_OK);
668 uint32_t Level = LnnGetDataSwitchLevel(&nodeInfo);
669 EXPECT_EQ(Level, 1);
670
671 Level = LnnGetDataSwitchLevel(nullptr);
672 EXPECT_NE(Level, 1);
673 }
674
675 /*
676 * @tc.name: LNN_NODE_INFO_Test_017
677 * @tc.desc: lnn node info function test, LnnSetDataSwitchLength, LnnGetDataSwitchLength
678 * @tc.type: FUNC
679 * @tc.require:
680 */
681 HWTEST_F(LNNNetLedgerCommonTest, LNN_NODE_INFO_Test_017, TestSize.Level1)
682 {
683 NodeInfo nodeInfo;
684 uint16_t dataSwitchLength = 1;
685
686 int32_t ret = LnnSetDataSwitchLength(nullptr, dataSwitchLength);
687 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
688
689 ret = LnnSetDataSwitchLength(&nodeInfo, dataSwitchLength);
690 EXPECT_EQ(ret, SOFTBUS_OK);
691 uint16_t Level = LnnGetDataSwitchLength(&nodeInfo);
692 EXPECT_EQ(Level, 1);
693
694 Level = LnnGetDataSwitchLength(nullptr);
695 EXPECT_NE(Level, 1);
696 }
697
698 /*
699 * @tc.name: LNN_NODE_INFO_Test_018
700 * @tc.desc: lnn node info function test LnnSetWifiDirectAddr, LnnGetWifiDirectAddr
701 * @tc.type: FUNC
702 * @tc.require:
703 */
704 HWTEST_F(LNNNetLedgerCommonTest, LNN_NODE_INFO_Test_018, TestSize.Level1)
705 {
706 NodeInfo nodeInfo;
707
708 int32_t ret = LnnSetWifiDirectAddr(nullptr, LOCAL_WIFIDIRECT_ADDR);
709 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
710
711 ret = LnnSetWifiDirectAddr(&nodeInfo, nullptr);
712 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
713
714 ret = LnnSetWifiDirectAddr(&nodeInfo, LOCAL_GO_MAC);
715 EXPECT_EQ(ret, SOFTBUS_OK);
716 const char *wifiDirectAddr = LnnGetWifiDirectAddr(&nodeInfo);
717 EXPECT_EQ(strcmp(wifiDirectAddr, LOCAL_GO_MAC), 0);
718 }
719
720 /*
721 * @tc.name: LNN_NODE_INFO_Test_019
722 * @tc.desc: lnn node info function test LnnSetStaticCapability, LnnGetStaticCapability
723 * @tc.type: FUNC
724 * @tc.require:
725 */
726 HWTEST_F(LNNNetLedgerCommonTest, LNN_NODE_INFO_Test_019, TestSize.Level1)
727 {
728 NodeInfo nodeInfo;
729 uint8_t capability = 4;
730
731 int32_t ret = LnnSetStaticCapability(nullptr, &capability, STATIC_CAP_LEN);
732 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
733 ret = LnnSetStaticCapability(&nodeInfo, nullptr, STATIC_CAP_LEN);
734 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
735
736 ret = LnnSetStaticCapability(&nodeInfo, &capability, 0);
737 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
738 ret = LnnSetStaticCapability(&nodeInfo, &capability, STATIC_CAP_LEN + 1);
739 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
740
741 ret = LnnSetStaticCapability(&nodeInfo, &capability, STATIC_CAP_LEN);
742 EXPECT_EQ(ret, SOFTBUS_OK);
743 uint8_t cap;
744 ret = LnnGetStaticCapability(&nodeInfo, &cap, STATIC_CAP_LEN);
745 EXPECT_EQ(ret, SOFTBUS_OK);
746
747 ret = LnnGetStaticCapability(nullptr, &cap, STATIC_CAP_LEN);
748 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
749 ret = LnnGetStaticCapability(&nodeInfo, nullptr, STATIC_CAP_LEN);
750 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
751 ret = LnnGetStaticCapability(&nodeInfo, &cap, STATIC_CAP_LEN + 1);
752 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
753 }
754
755 /*
756 * @tc.name: LNN_NODE_INFO_Test_020
757 * @tc.desc: lnn node info function test LnnSetPtk
758 * @tc.type: FUNC
759 * @tc.require:
760 */
761 HWTEST_F(LNNNetLedgerCommonTest, LNN_NODE_INFO_Test_020, TestSize.Level1)
762 {
763 NodeInfo nodeInfo;
764 char remotePtk[PTK_DEFAULT_LEN] = { "12345567890" };
765 char remotePtk2[10] = { "12345" };
766
767 LnnDumpRemotePtk(remotePtk, remotePtk2, nullptr);
768 int32_t ret = LnnSetPtk(nullptr, remotePtk);
769 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
770 ret = LnnSetPtk(&nodeInfo, nullptr);
771 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
772 ret = LnnSetPtk(&nodeInfo, remotePtk2);
773 EXPECT_EQ(ret, SOFTBUS_OK);
774
775 ret = LnnSetPtk(&nodeInfo, remotePtk);
776 EXPECT_EQ(ret, SOFTBUS_OK);
777 EXPECT_EQ(strcmp(remotePtk, nodeInfo.remotePtk), 0);
778 }
779
780 /*
781 * @tc.name: LNN_NODE_INFO_Test_021
782 * @tc.desc: lnn node info function test LnnSetScreenStatus
783 * @tc.type: FUNC
784 * @tc.require:
785 */
786 HWTEST_F(LNNNetLedgerCommonTest, LNN_NODE_INFO_Test_021, TestSize.Level1)
787 {
788 NodeInfo nodeInfo;
789
790 int32_t ret = LnnSetScreenStatus(nullptr, true);
791 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
792
793 ret = LnnSetScreenStatus(&nodeInfo, true);
794 EXPECT_EQ(ret, SOFTBUS_OK);
795 EXPECT_EQ(true, nodeInfo.isScreenOn);
796 ret = LnnSetScreenStatus(&nodeInfo, false);
797 EXPECT_EQ(false, nodeInfo.isScreenOn);
798 }
799
800 /*
801 * @tc.name: LNN_NODE_INFO_Test_022
802 * @tc.desc: lnn node info function test LnnSetScreenStatus
803 * @tc.type: FUNC
804 * @tc.require:
805 */
806 HWTEST_F(LNNNetLedgerCommonTest, LNN_NODE_INFO_Test_022, TestSize.Level1)
807 {
808 NodeInfo nodeInfo;
809 (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
810 uint8_t data[USERID_CHECKSUM_LEN];
811
812 int32_t ret = LnnSetUserIdCheckSum(nullptr, data, USERID_CHECKSUM_LEN);
813 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
814 ret = LnnSetUserIdCheckSum(&nodeInfo, nullptr, USERID_CHECKSUM_LEN);
815 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
816 ret = LnnSetUserIdCheckSum(&nodeInfo, data, 0);
817 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
818
819 ret = LnnSetUserIdCheckSum(&nodeInfo, data, USERID_CHECKSUM_LEN);
820 EXPECT_EQ(ret, SOFTBUS_OK);
821
822 ret = LnnGetUserIdCheckSum(nullptr, data, USERID_CHECKSUM_LEN);
823 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
824 ret = LnnGetUserIdCheckSum(&nodeInfo, nullptr, USERID_CHECKSUM_LEN);
825 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
826 ret = LnnGetUserIdCheckSum(&nodeInfo, data, 0);
827 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
828
829 ret = LnnGetUserIdCheckSum(&nodeInfo, data, USERID_CHECKSUM_LEN);
830 EXPECT_EQ(ret, SOFTBUS_OK);
831 }
832
833 /*
834 * @tc.name: LNN_NET_LEDGER_Test_001
835 * @tc.desc: lnn net ledger function test
836 * @tc.type: FUNC
837 * @tc.require:
838 */
839 HWTEST_F(LNNNetLedgerCommonTest, LNN_NET_LEDGER_Test_001, TestSize.Level1)
840 {
841 int32_t i;
842 EXPECT_TRUE(LnnInitNetLedger() == SOFTBUS_OK);
843 EXPECT_TRUE(LnnSetLocalStrInfo(STRING_KEY_NETWORKID, LOCAL_NETWORKID) == SOFTBUS_OK);
844 uint8_t info[BUF_LEN] = { 0 };
845 EXPECT_TRUE(LnnGetNodeKeyInfo(nullptr, 0, info, BUF_LEN) == SOFTBUS_INVALID_PARAM);
846 EXPECT_TRUE(LnnGetNodeKeyInfo(LOCAL_NETWORKID, 0, info, BUF_LEN) == SOFTBUS_OK);
847 EXPECT_TRUE(LnnGetNodeKeyInfo(LOCAL_NETWORKID, KEY_MAX_INDEX - 1, info, BUF_LEN) == SOFTBUS_OK);
848 for (i = 1; i < KEY_MAX_INDEX - 1; i++) {
849 EXPECT_TRUE(LnnGetNodeKeyInfo(LOCAL_NETWORKID, i, info, BUF_LEN) == SOFTBUS_OK);
850 }
851 for (i = 0; i < KEY_MAX_INDEX; i++) {
852 LnnGetNodeKeyInfo(REMOTE_NETWORKID, i, info, BUF_LEN);
853 }
854 LnnDeinitNetLedger();
855 }
856
857 /*
858 * @tc.name: LNN_NET_LEDGER_Test_002
859 * @tc.desc: lnn net ledger function test
860 * @tc.type: FUNC
861 * @tc.require:
862 */
863 HWTEST_F(LNNNetLedgerCommonTest, LNN_NET_LEDGER_Test_002, TestSize.Level1)
864 {
865 EXPECT_TRUE(LnnInitNetLedger() == SOFTBUS_OK);
866 EXPECT_TRUE(LnnSetLocalStrInfo(STRING_KEY_NETWORKID, LOCAL_NETWORKID) == SOFTBUS_OK);
867 EXPECT_TRUE(LnnSetNodeDataChangeFlag(nullptr, DATA_CHANGE_FLAG) == SOFTBUS_INVALID_PARAM);
868 EXPECT_TRUE(LnnSetNodeDataChangeFlag(LOCAL_NETWORKID, DATA_CHANGE_FLAG) == SOFTBUS_OK);
869 EXPECT_TRUE(
870 LnnSetNodeDataChangeFlag(REMOTE_NETWORKID, DATA_CHANGE_FLAG) == SOFTBUS_NETWORK_INVALID_DEV_INFO);
871 LnnDeinitNetLedger();
872 }
873
874 /*
875 * @tc.name: LNN_NET_LEDGER_Test_003
876 * @tc.desc: lnn net ledger function test
877 * @tc.type: FUNC
878 * @tc.require:
879 */
880 HWTEST_F(LNNNetLedgerCommonTest, LNN_NET_LEDGER_Test_003, TestSize.Level1)
881 {
882 static int32_t nodeKeyInfoLenTable[] = { UDID_BUF_LEN, UUID_BUF_LEN, UDID_BUF_LEN, MAC_LEN, IP_LEN,
883 DEVICE_NAME_BUF_LEN, LNN_COMMON_LEN, LNN_COMMON_LEN, SOFTBUS_INVALID_NUM, DATA_CHANGE_FLAG_BUF_LEN,
884 SHORT_ADDRESS_MAX_LEN };
885 EXPECT_TRUE(LnnInitNetLedger() == SOFTBUS_OK);
886 for (int32_t i = 0; i < KEY_MAX_INDEX; i++) {
887 EXPECT_TRUE(LnnGetNodeKeyInfoLen(i) == nodeKeyInfoLenTable[i]);
888 }
889 LnnDeinitNetLedger();
890 }
891
892 /*
893 * @tc.name: LNN_NET_LEDGER_Test_004
894 * @tc.desc: lnn net ledger function test
895 * @tc.type: FUNC
896 * @tc.require:
897 */
898 HWTEST_F(LNNNetLedgerCommonTest, LNN_NET_LEDGER_Test_004, TestSize.Level1)
899 {
900 EXPECT_TRUE(LnnInitNetLedger() == SOFTBUS_OK);
901 EXPECT_TRUE(LnnSetLocalStrInfo(STRING_KEY_DEV_UDID, LOCAL_UDID) == SOFTBUS_OK);
902 EXPECT_TRUE(LnnSetLocalStrInfo(STRING_KEY_NETWORKID, LOCAL_NETWORKID) == SOFTBUS_OK);
903 EXPECT_TRUE(LnnSetLocalStrInfo(STRING_KEY_UUID, LOCAL_UUID) == SOFTBUS_OK);
904 EXPECT_TRUE(LnnSetLocalStrInfo(STRING_KEY_BT_MAC, LOCAL_BT_MAC) == SOFTBUS_OK);
905 EXPECT_TRUE(LnnSetLocalStrInfo(STRING_KEY_WLAN_IP, LOCAL_WLAN_IP) == SOFTBUS_OK);
906 EXPECT_TRUE(LnnSetLocalNumInfo(NUM_KEY_NET_CAP, 1 << BIT_BR) == SOFTBUS_OK);
907 NodeBasicInfo nodeInfo;
908 (void)memset_s(&nodeInfo, sizeof(NodeBasicInfo), 0, sizeof(NodeBasicInfo));
909 (void)strncpy_s(nodeInfo.deviceName, DEVICE_NAME_BUF_LEN, NODE_DEVICE_NAME, strlen(NODE_DEVICE_NAME));
910 (void)strncpy_s(nodeInfo.networkId, NETWORK_ID_BUF_LEN, LOCAL_NETWORKID, strlen(LOCAL_NETWORKID));
911 SoftBusDumpBusCenterPrintInfo(DEFAULT_FD, nullptr);
912 SoftBusDumpBusCenterPrintInfo(DEFAULT_FD, &nodeInfo);
913 LnnDeinitNetLedger();
914 }
915
916 /*
917 * @tc.name: LOCAL_LEDGER_Test_001
918 * @tc.desc: lnn local key table test
919 * @tc.type: FUNC
920 * @tc.require:
921 */
922 HWTEST_F(LNNNetLedgerCommonTest, LOCAL_LEDGER_Test_001, TestSize.Level1)
923 {
924 EXPECT_TRUE(LnnInitLocalLedger() == SOFTBUS_OK);
925 static InfoKey getLocalStringInfoKeyTable[] = { STRING_KEY_HICE_VERSION, STRING_KEY_DEV_UDID, STRING_KEY_NETWORKID,
926 STRING_KEY_UUID, STRING_KEY_DEV_TYPE, STRING_KEY_DEV_NAME, STRING_KEY_BT_MAC, STRING_KEY_WLAN_IP,
927 STRING_KEY_NET_IF_NAME, STRING_KEY_MASTER_NODE_UDID, STRING_KEY_NODE_ADDR, STRING_KEY_P2P_MAC,
928 STRING_KEY_P2P_GO_MAC, STRING_KEY_OFFLINE_CODE, STRING_KEY_WIFIDIRECT_ADDR };
929 char buf[UDID_BUF_LEN] = { 0 };
930 int32_t ret;
931 uint32_t i;
932 LnnSetLocalStrInfo(STRING_KEY_DEV_UDID, LOCAL_UDID);
933 for (i = 0; i < sizeof(getLocalStringInfoKeyTable) / sizeof(InfoKey); i++) {
934 ret = LnnGetLocalStrInfo(getLocalStringInfoKeyTable[i], nullptr, UDID_BUF_LEN);
935 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
936 }
937 for (i = 0; i < sizeof(getLocalStringInfoKeyTable) / sizeof(InfoKey); i++) {
938 (void)memset_s(buf, UDID_BUF_LEN, 0, UDID_BUF_LEN);
939 ret = LnnGetLocalStrInfo(getLocalStringInfoKeyTable[i], buf, UDID_BUF_LEN);
940 EXPECT_TRUE(ret == SOFTBUS_OK);
941 }
942 LnnDeinitLocalLedger();
943 }
944
945 /*
946 * @tc.name: LOCAL_LEDGER_Test_002
947 * @tc.desc: lnn local key table test
948 * @tc.type: FUNC
949 * @tc.require:
950 */
951 HWTEST_F(LNNNetLedgerCommonTest, LOCAL_LEDGER_Test_002, TestSize.Level1)
952 {
953 EXPECT_TRUE(LnnInitLocalLedger() == SOFTBUS_OK);
954 int32_t ret = LnnSetLocalStrInfo(STRING_KEY_DEV_UDID, LOCAL_UDID);
955 EXPECT_TRUE(ret == SOFTBUS_OK);
956 ret = LnnSetLocalStrInfo(STRING_KEY_DEV_TYPE, LOCAL_DEVTYPE);
957 EXPECT_TRUE(ret == SOFTBUS_NETWORK_SET_LEDGER_INFO_ERR);
958 ret = LnnSetLocalStrInfo(STRING_KEY_BT_MAC, LOCAL_BT_MAC);
959 EXPECT_TRUE(ret == SOFTBUS_OK);
960 ret = LnnSetLocalStrInfo(STRING_KEY_WLAN_IP, LOCAL_WLAN_IP);
961 EXPECT_TRUE(ret == SOFTBUS_OK);
962 ret = LnnSetLocalStrInfo(STRING_KEY_NET_IF_NAME, LOCAL_NET_IF_NAME);
963 EXPECT_TRUE(ret == SOFTBUS_OK);
964 ret = LnnSetLocalStrInfo(STRING_KEY_MASTER_NODE_UDID, MASTER_NODE_UDID);
965 EXPECT_TRUE(ret == SOFTBUS_OK);
966 ret = LnnSetLocalStrInfo(STRING_KEY_NODE_ADDR, LOCAL_NODE_ADDR);
967 EXPECT_TRUE(ret == SOFTBUS_OK);
968 ret = LnnSetLocalStrInfo(STRING_KEY_P2P_MAC, LOCAL_P2P_MAC);
969 EXPECT_TRUE(ret == SOFTBUS_OK);
970 ret = LnnSetLocalStrInfo(STRING_KEY_P2P_GO_MAC, LOCAL_GO_MAC);
971 EXPECT_TRUE(ret == SOFTBUS_OK);
972 ret = LnnSetLocalStrInfo(STRING_KEY_WIFIDIRECT_ADDR, LOCAL_WIFIDIRECT_ADDR);
973 EXPECT_TRUE(ret == SOFTBUS_OK);
974 LnnDeinitLocalLedger();
975 }
976
977 /*
978 * @tc.name: LOCAL_LEDGER_Test_003
979 * @tc.desc: lnn local key table test
980 * @tc.type: FUNC
981 * @tc.require:
982 */
983 HWTEST_F(LNNNetLedgerCommonTest, LOCAL_LEDGER_Test_003, TestSize.Level1)
984 {
985 EXPECT_TRUE(LnnInitLocalLedger() == SOFTBUS_OK);
986 static InfoKey getLocalNumInfoKeyTable[] = { NUM_KEY_SESSION_PORT, NUM_KEY_AUTH_PORT, NUM_KEY_PROXY_PORT,
987 NUM_KEY_NET_CAP, NUM_KEY_DISCOVERY_TYPE, NUM_KEY_DEV_TYPE_ID, NUM_KEY_MASTER_NODE_WEIGHT, NUM_KEY_P2P_ROLE,
988 NUM_KEY_STATIC_CAP_LEN };
989 int32_t ret, info;
990 LnnSetLocalNumInfo(NUM_KEY_AUTH_PORT, LOCAL_AUTH_PORT);
991 for (uint32_t i = 0; i < sizeof(getLocalNumInfoKeyTable) / sizeof(InfoKey); i++) {
992 info = 0;
993 ret = LnnGetLocalNumInfo(getLocalNumInfoKeyTable[i], &info);
994 EXPECT_TRUE(ret == SOFTBUS_OK);
995 }
996 LnnDeinitLocalLedger();
997 }
998
999 /*
1000 * @tc.name: LOCAL_LEDGER_Test_004
1001 * @tc.desc: lnn local key table test
1002 * @tc.type: FUNC
1003 * @tc.require:
1004 */
1005 HWTEST_F(LNNNetLedgerCommonTest, LOCAL_LEDGER_Test_004, TestSize.Level1)
1006 {
1007 EXPECT_TRUE(LnnInitLocalLedger() == SOFTBUS_OK);
1008 int32_t ret = LnnSetLocalNumInfo(NUM_KEY_SESSION_PORT, LOCAL_SESSION_PORT);
1009 EXPECT_TRUE(ret == SOFTBUS_OK);
1010 ret = LnnSetLocalNumInfo(NUM_KEY_AUTH_PORT, LOCAL_AUTH_PORT);
1011 EXPECT_TRUE(ret == SOFTBUS_OK);
1012 ret = LnnSetLocalNumInfo(NUM_KEY_PROXY_PORT, LOCAL_PROXY_PORT);
1013 EXPECT_TRUE(ret == SOFTBUS_OK);
1014 ret = LnnSetLocalNumInfo(NUM_KEY_NET_CAP, LOCAL_CAPACITY);
1015 EXPECT_TRUE(ret == SOFTBUS_OK);
1016 ret = LnnSetLocalNumInfo(NUM_KEY_MASTER_NODE_WEIGHT, MASTER_WEIGHT);
1017 EXPECT_TRUE(ret == SOFTBUS_OK);
1018 ret = LnnSetLocalNumInfo(NUM_KEY_P2P_ROLE, P2P_ROLE);
1019 EXPECT_TRUE(ret == SOFTBUS_OK);
1020 ret = LnnSetLocalNumInfo(NUM_KEY_STATIC_CAP_LEN, STATIC_LEN);
1021 EXPECT_TRUE(ret == SOFTBUS_OK);
1022 LnnDeinitLocalLedger();
1023 }
1024
1025 /*
1026 * @tc.name: LOCAL_LEDGER_Test_005
1027 * @tc.desc: lnn local key table test
1028 * @tc.type: FUNC
1029 * @tc.require:
1030 */
1031 HWTEST_F(LNNNetLedgerCommonTest, LOCAL_LEDGER_Test_005, TestSize.Level1)
1032 {
1033 int64_t info;
1034 EXPECT_TRUE(LnnInitLocalLedger() == SOFTBUS_OK);
1035 int32_t ret = LnnGetLocalNum64Info(NUM_KEY_TRANS_PROTOCOLS, &info);
1036 EXPECT_TRUE(ret == SOFTBUS_OK);
1037 ret = LnnGetLocalDeviceInfo(nullptr);
1038 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1039 EXPECT_TRUE(LnnIsMasterNode() == false);
1040 LnnDeinitLocalLedger();
1041 LnnDeinitLocalLedger();
1042 }
1043
1044 /*
1045 * @tc.name: LNN_FEATURE_CAPABILTY_001
1046 * @tc.desc: lnn feature capability test
1047 * @tc.type: FUNC
1048 * @tc.require:
1049 */
1050 HWTEST_F(LNNNetLedgerCommonTest, LNN_FEATURE_CAPABILTY_001, TestSize.Level1)
1051 {
1052 uint64_t feature;
1053 int32_t ret = LnnSetFeatureCapability(nullptr, BIT_FEATURE_COUNT);
1054 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1055 ret = LnnSetFeatureCapability(nullptr, BIT_BR_DUP);
1056 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1057 ret = LnnSetFeatureCapability(&feature, BIT_FEATURE_COUNT);
1058 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1059
1060 ret = LnnSetFeatureCapability(&feature, BIT_BR_DUP);
1061 EXPECT_EQ(ret, SOFTBUS_OK);
1062 EXPECT_EQ(IsFeatureSupport(feature, BIT_BR_DUP), true);
1063
1064 ret = LnnClearFeatureCapability(nullptr, BIT_FEATURE_COUNT);
1065 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1066 ret = LnnClearFeatureCapability(nullptr, BIT_BR_DUP);
1067 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1068 ret = LnnClearFeatureCapability(&feature, BIT_FEATURE_COUNT);
1069 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1070
1071 ret = LnnClearFeatureCapability(&feature, BIT_BR_DUP);
1072 EXPECT_EQ(ret, SOFTBUS_OK);
1073 EXPECT_EQ(IsFeatureSupport(feature, BIT_BR_DUP), false);
1074 }
1075
1076 /*
1077 * @tc.name: LNN_SET_DATA_LEVEL_001
1078 * @tc.desc: lnn node info function test LnnSetDataLevel
1079 * @tc.type: FUNC
1080 * @tc.require:
1081 */
1082 HWTEST_F(LNNNetLedgerCommonTest, LNN_SET_DATA_LEVEL_001, TestSize.Level1)
1083 {
1084 DataLevel dataLevel;
1085 dataLevel.dynamicLevel = 0;
1086 dataLevel.staticLevel = 0;
1087 dataLevel.switchLevel = 0;
1088 dataLevel.switchLength = 0;
1089 bool isSwitchLevelChanged = false;
1090 NetLedgerCommonInterfaceMock netLedgerMock;
1091 EXPECT_CALL(netLedgerMock, LnnSetLocalNumU16Info(_, _)).WillOnce(Return(SOFTBUS_INVALID_PARAM));
1092 uint32_t ret = LnnSetDataLevel(&dataLevel, &isSwitchLevelChanged);
1093 EXPECT_EQ(ret, SOFTBUS_NETWORK_SET_LEDGER_INFO_ERR);
1094 }
1095
1096 /*
1097 * @tc.name: LNN_SET_DATA_LEVEL_002
1098 * @tc.desc: lnn node info function test LnnSetDataLevel
1099 * @tc.type: FUNC
1100 * @tc.require:
1101 */
1102 HWTEST_F(LNNNetLedgerCommonTest, LNN_SET_DATA_LEVEL_002, TestSize.Level1)
1103 {
1104 DataLevel *dataLevel = nullptr;
1105 bool isSwitchLevelChanged = false;
1106 uint32_t ret = LnnSetDataLevel(dataLevel, &isSwitchLevelChanged);
1107 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1108 }
1109
1110 /*
1111 * @tc.name: LNN_SET_DATA_LEVEL_003
1112 * @tc.desc: lnn node info function test LnnSetDataLevel
1113 * @tc.type: FUNC
1114 * @tc.require:
1115 */
1116 HWTEST_F(LNNNetLedgerCommonTest, LNN_SET_DATA_LEVEL_003, TestSize.Level1)
1117 {
1118 DataLevel dataLevel;
1119 dataLevel.dynamicLevel = 0;
1120 dataLevel.staticLevel = 0;
1121 dataLevel.switchLevel = 0;
1122 dataLevel.switchLength = 0;
1123 bool *isSwitchLevelChanged = nullptr;
1124 uint32_t ret = LnnSetDataLevel(&dataLevel, isSwitchLevelChanged);
1125 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1126 }
1127 } // namespace OHOS