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