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 <gtest/gtest.h>
17 #include <securec.h>
18 #include <cstddef>
19 #include <cstdlib>
20 #include <cstring>
21 #include <cstdint>
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_huks_utils.h"
28 #include "lnn_local_net_ledger.h"
29 #include "lnn_log.h"
30 #include "lnn_meta_node_ledger.h"
31 #include "lnn_net_capability.h"
32 #include "lnn_net_ledger.h"
33 #include "lnn_node_info.h"
34 #include "lnn_oobe_manager.h"
35 #include "softbus_adapter_mem.h"
36 #include "softbus_errcode.h"
37 #include "softbus_feature_config.h"
38 #include "softbus_utils.h"
39
40 #define ONE_BIT_MAX_HEX 15
41 #define DEVICE_TYPE_MAX_LENGTH 3
42 #define LEFT_SHIFT_DEVICE_TYPE_LENGTH (DEVICE_TYPE_MAX_LENGTH * 4)
43
44 namespace OHOS {
45 using namespace testing::ext;
46 constexpr char NODE_DEVICE_NAME[] = "node1_test";
47 constexpr char INVALID_DEVICE_NAME[] =
48 "ASDFGHJKLPASDFGHJKLPASDFGHJKLPASDFGHJKLPASDFGHJKLPASDFGHJKLPASDFGHJKLPASDFGHJK\
49 LPASDFGHJKLPASDFGHJKLPASDFGHJKLPASDFGHJKLPASDFGHJKLPASDFGHJKLPASDFGHJKLPASDFGHJ\
50 KLPASDFGHJKLPASDFGHJKLPASDFGHJKLPASDFGHJKLP";
51 constexpr char DEVICE_TYPE[] = "PAD";
52 constexpr char INVALID_DEVICE_TYPE[] = "PADPAD";
53 constexpr int32_t PORT = 1;
54 constexpr uint64_t PROTOCOLS = 1;
55 constexpr char LOCAL_NETWORKID[] = "123456LOCAL";
56 constexpr char REMOTE_NETWORKID[] = "234567REMOTE";
57 constexpr uint32_t BUF_LEN = 128;
58 constexpr int32_t KEY_MAX_INDEX = 11;
59 constexpr uint16_t DATA_CHANGE_FLAG = 1;
60 constexpr char LOCAL_UDID[] = "123456LOCALTEST";
61 constexpr char LOCAL_UUID[] = "235999LOCAL";
62 constexpr char LOCAL_BT_MAC[] = "56789TUT";
63 constexpr char LOCAL_WLAN_IP[] = "10.146.181.134";
64 constexpr int32_t DEFAULT_FD = 1;
65 constexpr char LOCAL_DEVTYPE[] = "TYPE_WATCH";
66 constexpr char LOCAL_NET_IF_NAME[] = "LOCAL";
67 constexpr char MASTER_NODE_UDID[] = "234567LOCALTEST";
68 constexpr char LOCAL_NODE_ADDR[] = "ADDR";
69 constexpr char LOCAL_P2P_MAC[] = "11:22:33:44:55";
70 constexpr char LOCAL_GO_MAC[] = "22:33:44:55:66";
71 constexpr char LOCAL_WIFIDIRECT_ADDR[] = "55:66:77:88:99";
72 constexpr uint32_t LOCAL_SESSION_PORT = 5000;
73 constexpr uint32_t LOCAL_AUTH_PORT = 6000;
74 constexpr uint32_t LOCAL_PROXY_PORT = 7000;
75 constexpr uint32_t LOCAL_CAPACITY = 3;
76 constexpr int32_t MASTER_WEIGHT = 10;
77 constexpr int32_t P2P_ROLE = 1;
78 constexpr int32_t STATIC_LEN = 10;
79 using namespace testing;
80 class LNNNetLedgerCommonTest : public testing::Test {
81 public:
82 static void SetUpTestCase();
83 static void TearDownTestCase();
84 void SetUp();
85 void TearDown();
86 };
87
SetUpTestCase()88 void LNNNetLedgerCommonTest::SetUpTestCase()
89 {
90 }
91
TearDownTestCase()92 void LNNNetLedgerCommonTest::TearDownTestCase()
93 {
94 }
95
SetUp()96 void LNNNetLedgerCommonTest::SetUp()
97 {
98 LNN_LOGI(LNN_TEST, "LNNNetLedgerCommonTest start");
99 }
100
TearDown()101 void LNNNetLedgerCommonTest::TearDown()
102 {
103 }
104
105 /*
106 * @tc.name: LNN_DEVICE_INFO_Test_001
107 * @tc.desc: lnn device info function test
108 * @tc.type: FUNC
109 * @tc.require:
110 */
111 HWTEST_F(LNNNetLedgerCommonTest, LNN_DEVICE_INFO_Test_001, TestSize.Level1)
112 {
113 DeviceBasicInfo info;
114 uint16_t typeId = 0;
115 int32_t ret = memset_s(&info, sizeof(DeviceBasicInfo), 0, sizeof(DeviceBasicInfo));
116 EXPECT_TRUE(ret == EOK);
117 EXPECT_TRUE(LnnGetDeviceName(nullptr) == NULL);
118 LnnGetDeviceName(&info);
119 EXPECT_TRUE(LnnSetDeviceName(nullptr, NODE_DEVICE_NAME) == SOFTBUS_INVALID_PARAM);
120 EXPECT_TRUE(LnnSetDeviceName(&info, nullptr) == SOFTBUS_INVALID_PARAM);
121 EXPECT_TRUE(LnnSetDeviceName(&info, INVALID_DEVICE_NAME) == SOFTBUS_INVALID_PARAM);
122 EXPECT_TRUE(LnnSetDeviceName(&info, NODE_DEVICE_NAME) == SOFTBUS_OK);
123 EXPECT_TRUE(LnnGetDeviceTypeId(nullptr, &typeId) == SOFTBUS_INVALID_PARAM);
124 EXPECT_TRUE(LnnGetDeviceTypeId(&info, nullptr) == SOFTBUS_INVALID_PARAM);
125 EXPECT_TRUE(LnnGetDeviceTypeId(&info, &typeId) == SOFTBUS_OK);
126 EXPECT_TRUE(LnnConvertDeviceTypeToId(nullptr, nullptr) == SOFTBUS_INVALID_PARAM);
127 EXPECT_TRUE(LnnConvertDeviceTypeToId(INVALID_DEVICE_TYPE, &typeId) == SOFTBUS_ERR);
128 EXPECT_TRUE(LnnConvertDeviceTypeToId(DEVICE_TYPE, &typeId) == SOFTBUS_OK);
129 typeId = 0;
130 LnnConvertIdToDeviceType(TYPE_WATCH_ID);
131 LnnConvertIdToDeviceType(typeId);
132 typeId = ONE_BIT_MAX_HEX << LEFT_SHIFT_DEVICE_TYPE_LENGTH;
133 EXPECT_TRUE(LnnConvertIdToDeviceType(typeId) != nullptr);
134 }
135
136 /*
137 * @tc.name: LNN_HUKS_UTILS_Test_001
138 * @tc.desc: lnn huks utils function test
139 * @tc.type: FUNC
140 * @tc.require:
141 */
142 HWTEST_F(LNNNetLedgerCommonTest, LNN_HUKS_UTILS_Test_001, TestSize.Level1)
143 {
144 struct HksBlob keyAlias;
145 (void)memset_s(&keyAlias, sizeof(HksBlob), 0, sizeof(HksBlob));
146 EXPECT_TRUE(LnnGenerateKeyByHuks(nullptr) == SOFTBUS_INVALID_PARAM);
147 EXPECT_TRUE(LnnGenerateKeyByHuks(&keyAlias) == SOFTBUS_ERR);
148 EXPECT_TRUE(LnnDeleteKeyByHuks(nullptr) == SOFTBUS_INVALID_PARAM);
149 EXPECT_TRUE(LnnDeleteKeyByHuks(&keyAlias) == SOFTBUS_OK);
150 EXPECT_TRUE(LnnEncryptDataByHuks(nullptr, nullptr, nullptr) == SOFTBUS_INVALID_PARAM);
151 EXPECT_TRUE(LnnDecryptDataByHuks(nullptr, nullptr, nullptr) == SOFTBUS_INVALID_PARAM);
152 }
153
154 /*
155 * @tc.name: LNN_NET_CAPABILITY_Test_001
156 * @tc.desc: lnn net capability function test
157 * @tc.type: FUNC
158 * @tc.require:
159 */
160 HWTEST_F(LNNNetLedgerCommonTest, LNN_NET_CAPABILITY_Test_001, TestSize.Level1)
161 {
162 uint32_t capability = 0;
163 EXPECT_TRUE(LnnSetNetCapability(nullptr, BIT_COUNT) == SOFTBUS_INVALID_PARAM);
164 EXPECT_TRUE(LnnClearNetCapability(nullptr, BIT_COUNT) == SOFTBUS_INVALID_PARAM);
165 EXPECT_TRUE(LnnClearNetCapability(&capability, BIT_BLE) == SOFTBUS_OK);
166 }
167
168 /*
169 * @tc.name: LNN_NODE_INFO_Test_001
170 * @tc.desc: lnn node info function test
171 * @tc.type: FUNC
172 * @tc.require:
173 */
174 HWTEST_F(LNNNetLedgerCommonTest, LNN_NODE_INFO_Test_001, TestSize.Level1)
175 {
176 EXPECT_TRUE(LnnHasDiscoveryType(nullptr, DISCOVERY_TYPE_WIFI) == false);
177 EXPECT_TRUE(LnnGetDeviceUdid(nullptr) == nullptr);
178 EXPECT_TRUE(LnnSetDeviceUdid(nullptr, nullptr) == SOFTBUS_INVALID_PARAM);
179 EXPECT_TRUE(LnnSetDiscoveryType(nullptr, DISCOVERY_TYPE_WIFI) == SOFTBUS_INVALID_PARAM);
180 EXPECT_TRUE(LnnClearDiscoveryType(nullptr, DISCOVERY_TYPE_WIFI) == SOFTBUS_INVALID_PARAM);
181 EXPECT_TRUE(LnnIsNodeOnline(nullptr) == false);
182 LnnSetNodeConnStatus(nullptr, STATUS_ONLINE);
183 LnnGetBtMac(nullptr);
184 LnnSetBtMac(nullptr, nullptr);
185 LnnGetNetIfName(nullptr);
186 LnnSetNetIfName(nullptr, nullptr);
187 LnnGetWiFiIp(nullptr);
188 LnnSetWiFiIp(nullptr, nullptr);
189 EXPECT_TRUE(LnnGetMasterUdid(nullptr) == nullptr);
190 EXPECT_TRUE(LnnSetMasterUdid(nullptr, nullptr) == SOFTBUS_INVALID_PARAM);
191 EXPECT_TRUE(LnnGetAuthPort(nullptr) == SOFTBUS_INVALID_PARAM);
192 EXPECT_TRUE(LnnSetAuthPort(nullptr, PORT) == SOFTBUS_INVALID_PARAM);
193 EXPECT_TRUE(LnnGetSessionPort(nullptr) == SOFTBUS_INVALID_PARAM);
194 EXPECT_TRUE(LnnSetSessionPort(nullptr, PORT) == SOFTBUS_INVALID_PARAM);
195 EXPECT_TRUE(LnnGetProxyPort(nullptr) == SOFTBUS_INVALID_PARAM);
196 EXPECT_TRUE(LnnSetProxyPort(nullptr, PORT) == SOFTBUS_INVALID_PARAM);
197 EXPECT_TRUE(LnnSetP2pRole(nullptr, PORT) == SOFTBUS_INVALID_PARAM);
198 EXPECT_TRUE(LnnGetP2pRole(nullptr) == 0);
199 EXPECT_TRUE(LnnSetP2pMac(nullptr, nullptr) == SOFTBUS_INVALID_PARAM);
200 EXPECT_TRUE(LnnGetP2pMac(nullptr) == nullptr);
201 EXPECT_TRUE(LnnSetP2pGoMac(nullptr, nullptr) == SOFTBUS_INVALID_PARAM);
202 EXPECT_TRUE(LnnGetWifiDirectAddr(nullptr) == nullptr);
203 EXPECT_TRUE(LnnSetWifiDirectAddr(nullptr, nullptr) == SOFTBUS_INVALID_PARAM);
204 EXPECT_TRUE(LnnGetP2pGoMac(nullptr) == nullptr);
205 EXPECT_TRUE(LnnGetSupportedProtocols(nullptr) == 0);
206 EXPECT_TRUE(LnnSetSupportedProtocols(nullptr, PROTOCOLS) == SOFTBUS_INVALID_PARAM);
207 EXPECT_TRUE(LnnSetStaticCapability(nullptr, nullptr, 0) == SOFTBUS_INVALID_PARAM);
208 EXPECT_TRUE(LnnGetStaticCapability(nullptr, nullptr, 0) == SOFTBUS_INVALID_PARAM);
209 EXPECT_TRUE(LnnSetPtk(nullptr, nullptr) == SOFTBUS_INVALID_PARAM);
210 }
211
212 /*
213 * @tc.name: LNN_NET_LEDGER_Test_001
214 * @tc.desc: lnn net ledger function test
215 * @tc.type: FUNC
216 * @tc.require:
217 */
218 HWTEST_F(LNNNetLedgerCommonTest, LNN_NET_LEDGER_Test_001, TestSize.Level1)
219 {
220 int32_t i;
221 EXPECT_TRUE(LnnInitNetLedger() == SOFTBUS_OK);
222 EXPECT_TRUE(LnnSetLocalStrInfo(STRING_KEY_NETWORKID, LOCAL_NETWORKID) == SOFTBUS_OK);
223 uint8_t info[BUF_LEN] = {0};
224 EXPECT_TRUE(LnnGetNodeKeyInfo(nullptr, 0, info, BUF_LEN) == SOFTBUS_INVALID_PARAM);
225 EXPECT_TRUE(LnnGetNodeKeyInfo(LOCAL_NETWORKID, 0, info, BUF_LEN) == SOFTBUS_OK);
226 EXPECT_TRUE(LnnGetNodeKeyInfo(LOCAL_NETWORKID, KEY_MAX_INDEX - 1, info, BUF_LEN) == SOFTBUS_OK);
227 for (i = 1; i < KEY_MAX_INDEX - 1; i++) {
228 EXPECT_TRUE(LnnGetNodeKeyInfo(LOCAL_NETWORKID, i, info, BUF_LEN) == SOFTBUS_OK);
229 }
230 for (i = 0; i < KEY_MAX_INDEX; i++) {
231 LnnGetNodeKeyInfo(REMOTE_NETWORKID, i, info, BUF_LEN);
232 }
233 LnnDeinitNetLedger();
234 }
235
236 /*
237 * @tc.name: LNN_NET_LEDGER_Test_002
238 * @tc.desc: lnn net ledger function test
239 * @tc.type: FUNC
240 * @tc.require:
241 */
242 HWTEST_F(LNNNetLedgerCommonTest, LNN_NET_LEDGER_Test_002, TestSize.Level1)
243 {
244 EXPECT_TRUE(LnnInitNetLedger() == SOFTBUS_OK);
245 EXPECT_TRUE(LnnSetLocalStrInfo(STRING_KEY_NETWORKID, LOCAL_NETWORKID) == SOFTBUS_OK);
246 EXPECT_TRUE(LnnSetNodeDataChangeFlag(nullptr, DATA_CHANGE_FLAG) == SOFTBUS_INVALID_PARAM);
247 EXPECT_TRUE(LnnSetNodeDataChangeFlag(LOCAL_NETWORKID, DATA_CHANGE_FLAG) == SOFTBUS_OK);
248 EXPECT_TRUE(LnnSetNodeDataChangeFlag(REMOTE_NETWORKID, DATA_CHANGE_FLAG) == SOFTBUS_ERR);
249 LnnDeinitNetLedger();
250 }
251
252 /*
253 * @tc.name: LNN_NET_LEDGER_Test_003
254 * @tc.desc: lnn net ledger function test
255 * @tc.type: FUNC
256 * @tc.require:
257 */
258 HWTEST_F(LNNNetLedgerCommonTest, LNN_NET_LEDGER_Test_003, TestSize.Level1)
259 {
260 static int32_t nodeKeyInfoLenTable[] = {
261 UDID_BUF_LEN,
262 UUID_BUF_LEN,
263 UDID_BUF_LEN,
264 MAC_LEN,
265 IP_LEN,
266 DEVICE_NAME_BUF_LEN,
267 LNN_COMMON_LEN,
268 LNN_COMMON_LEN,
269 SOFTBUS_ERR,
270 DATA_CHANGE_FLAG_BUF_LEN,
271 SHORT_ADDRESS_MAX_LEN
272 };
273 EXPECT_TRUE(LnnInitNetLedger() == SOFTBUS_OK);
274 for (int32_t i = 0; i < KEY_MAX_INDEX; i++) {
275 EXPECT_TRUE(LnnGetNodeKeyInfoLen(i) == nodeKeyInfoLenTable[i]);
276 }
277 LnnDeinitNetLedger();
278 }
279
280 /*
281 * @tc.name: LNN_NET_LEDGER_Test_004
282 * @tc.desc: lnn net ledger function test
283 * @tc.type: FUNC
284 * @tc.require:
285 */
286 HWTEST_F(LNNNetLedgerCommonTest, LNN_NET_LEDGER_Test_004, TestSize.Level1)
287 {
288 EXPECT_TRUE(LnnInitNetLedger() == SOFTBUS_OK);
289 EXPECT_TRUE(LnnSetLocalStrInfo(STRING_KEY_DEV_UDID, LOCAL_UDID) == SOFTBUS_OK);
290 EXPECT_TRUE(LnnSetLocalStrInfo(STRING_KEY_NETWORKID, LOCAL_NETWORKID) == SOFTBUS_OK);
291 EXPECT_TRUE(LnnSetLocalStrInfo(STRING_KEY_UUID, LOCAL_UUID) == SOFTBUS_OK);
292 EXPECT_TRUE(LnnSetLocalStrInfo(STRING_KEY_BT_MAC, LOCAL_BT_MAC) == SOFTBUS_OK);
293 EXPECT_TRUE(LnnSetLocalStrInfo(STRING_KEY_WLAN_IP, LOCAL_WLAN_IP) == SOFTBUS_OK);
294 EXPECT_TRUE(LnnSetLocalNumInfo(NUM_KEY_NET_CAP, 1 << BIT_BR) == SOFTBUS_OK);
295 NodeBasicInfo nodeInfo;
296 (void)memset_s(&nodeInfo, sizeof(NodeBasicInfo), 0, sizeof(NodeBasicInfo));
297 (void)strncpy_s(nodeInfo.deviceName, DEVICE_NAME_BUF_LEN, NODE_DEVICE_NAME, strlen(NODE_DEVICE_NAME));
298 (void)strncpy_s(nodeInfo.networkId, NETWORK_ID_BUF_LEN, LOCAL_NETWORKID, strlen(LOCAL_NETWORKID));
299 SoftBusDumpBusCenterPrintInfo(DEFAULT_FD, nullptr);
300 SoftBusDumpBusCenterPrintInfo(DEFAULT_FD, &nodeInfo);
301 LnnDeinitNetLedger();
302 }
303
304 /*
305 * @tc.name: LOCAL_LEDGER_Test_001
306 * @tc.desc: lnn local key table test
307 * @tc.type: FUNC
308 * @tc.require:
309 */
310 HWTEST_F(LNNNetLedgerCommonTest, LOCAL_LEDGER_Test_001, TestSize.Level1)
311 {
312 EXPECT_TRUE(LnnInitLocalLedger() == SOFTBUS_OK);
313 static InfoKey getLocalStringInfoKeyTable[] = {
314 STRING_KEY_HICE_VERSION,
315 STRING_KEY_DEV_UDID,
316 STRING_KEY_NETWORKID,
317 STRING_KEY_UUID,
318 STRING_KEY_DEV_TYPE,
319 STRING_KEY_DEV_NAME,
320 STRING_KEY_BT_MAC,
321 STRING_KEY_WLAN_IP,
322 STRING_KEY_NET_IF_NAME,
323 STRING_KEY_MASTER_NODE_UDID,
324 STRING_KEY_NODE_ADDR,
325 STRING_KEY_P2P_MAC,
326 STRING_KEY_P2P_GO_MAC,
327 STRING_KEY_OFFLINE_CODE,
328 STRING_KEY_WIFIDIRECT_ADDR
329 };
330 char buf[UDID_BUF_LEN] = {0};
331 int32_t ret;
332 uint32_t i;
333 LnnSetLocalStrInfo(STRING_KEY_DEV_UDID, LOCAL_UDID);
334 for (i = 0; i < sizeof(getLocalStringInfoKeyTable) / sizeof(InfoKey); i++) {
335 ret = LnnGetLocalStrInfo(getLocalStringInfoKeyTable[i], nullptr, UDID_BUF_LEN);
336 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
337 }
338 for (i = 0; i < sizeof(getLocalStringInfoKeyTable) / sizeof(InfoKey); i++) {
339 (void)memset_s(buf, UDID_BUF_LEN, 0, UDID_BUF_LEN);
340 ret = LnnGetLocalStrInfo(getLocalStringInfoKeyTable[i], buf, UDID_BUF_LEN);
341 EXPECT_TRUE(ret == SOFTBUS_OK);
342 }
343 LnnDeinitLocalLedger();
344 }
345
346 /*
347 * @tc.name: LOCAL_LEDGER_Test_002
348 * @tc.desc: lnn local key table test
349 * @tc.type: FUNC
350 * @tc.require:
351 */
352 HWTEST_F(LNNNetLedgerCommonTest, LOCAL_LEDGER_Test_002, TestSize.Level1)
353 {
354 EXPECT_TRUE(LnnInitLocalLedger() == SOFTBUS_OK);
355 int32_t ret = LnnSetLocalStrInfo(STRING_KEY_DEV_UDID, LOCAL_UDID);
356 EXPECT_TRUE(ret == SOFTBUS_OK);
357 ret = LnnSetLocalStrInfo(STRING_KEY_DEV_TYPE, LOCAL_DEVTYPE);
358 EXPECT_TRUE(ret == SOFTBUS_ERR);
359 ret = LnnSetLocalStrInfo(STRING_KEY_BT_MAC, LOCAL_BT_MAC);
360 EXPECT_TRUE(ret == SOFTBUS_OK);
361 ret = LnnSetLocalStrInfo(STRING_KEY_WLAN_IP, LOCAL_WLAN_IP);
362 EXPECT_TRUE(ret == SOFTBUS_OK);
363 ret = LnnSetLocalStrInfo(STRING_KEY_NET_IF_NAME, LOCAL_NET_IF_NAME);
364 EXPECT_TRUE(ret == SOFTBUS_OK);
365 ret = LnnSetLocalStrInfo(STRING_KEY_MASTER_NODE_UDID, MASTER_NODE_UDID);
366 EXPECT_TRUE(ret == SOFTBUS_OK);
367 ret = LnnSetLocalStrInfo(STRING_KEY_NODE_ADDR, LOCAL_NODE_ADDR);
368 EXPECT_TRUE(ret == SOFTBUS_OK);
369 ret = LnnSetLocalStrInfo(STRING_KEY_P2P_MAC, LOCAL_P2P_MAC);
370 EXPECT_TRUE(ret == SOFTBUS_OK);
371 ret = LnnSetLocalStrInfo(STRING_KEY_P2P_GO_MAC, LOCAL_GO_MAC);
372 EXPECT_TRUE(ret == SOFTBUS_OK);
373 ret = LnnSetLocalStrInfo(STRING_KEY_WIFIDIRECT_ADDR, LOCAL_WIFIDIRECT_ADDR);
374 EXPECT_TRUE(ret == SOFTBUS_OK);
375 LnnDeinitLocalLedger();
376 }
377
378 /*
379 * @tc.name: LOCAL_LEDGER_Test_003
380 * @tc.desc: lnn local key table test
381 * @tc.type: FUNC
382 * @tc.require:
383 */
384 HWTEST_F(LNNNetLedgerCommonTest, LOCAL_LEDGER_Test_003, TestSize.Level1)
385 {
386 EXPECT_TRUE(LnnInitLocalLedger() == SOFTBUS_OK);
387 static InfoKey getLocalNumInfoKeyTable[] = {
388 NUM_KEY_SESSION_PORT,
389 NUM_KEY_AUTH_PORT,
390 NUM_KEY_PROXY_PORT,
391 NUM_KEY_NET_CAP,
392 NUM_KEY_DISCOVERY_TYPE,
393 NUM_KEY_DEV_TYPE_ID,
394 NUM_KEY_MASTER_NODE_WEIGHT,
395 NUM_KEY_P2P_ROLE,
396 NUM_KEY_STATIC_CAP_LEN
397 };
398 int32_t ret, info;
399 LnnSetLocalNumInfo(NUM_KEY_AUTH_PORT, LOCAL_AUTH_PORT);
400 for (uint32_t i = 0; i < sizeof(getLocalNumInfoKeyTable) / sizeof(InfoKey); i++) {
401 info = 0;
402 ret = LnnGetLocalNumInfo(getLocalNumInfoKeyTable[i], &info);
403 EXPECT_TRUE(ret == SOFTBUS_OK);
404 }
405 LnnDeinitLocalLedger();
406 }
407
408 /*
409 * @tc.name: LOCAL_LEDGER_Test_004
410 * @tc.desc: lnn local key table test
411 * @tc.type: FUNC
412 * @tc.require:
413 */
414 HWTEST_F(LNNNetLedgerCommonTest, LOCAL_LEDGER_Test_004, TestSize.Level1)
415 {
416 EXPECT_TRUE(LnnInitLocalLedger() == SOFTBUS_OK);
417 int32_t ret = LnnSetLocalNumInfo(NUM_KEY_SESSION_PORT, LOCAL_SESSION_PORT);
418 EXPECT_TRUE(ret == SOFTBUS_OK);
419 ret = LnnSetLocalNumInfo(NUM_KEY_AUTH_PORT, LOCAL_AUTH_PORT);
420 EXPECT_TRUE(ret == SOFTBUS_OK);
421 ret = LnnSetLocalNumInfo(NUM_KEY_PROXY_PORT, LOCAL_PROXY_PORT);
422 EXPECT_TRUE(ret == SOFTBUS_OK);
423 ret = LnnSetLocalNumInfo(NUM_KEY_NET_CAP, LOCAL_CAPACITY);
424 EXPECT_TRUE(ret == SOFTBUS_OK);
425 ret = LnnSetLocalNumInfo(NUM_KEY_MASTER_NODE_WEIGHT, MASTER_WEIGHT);
426 EXPECT_TRUE(ret == SOFTBUS_OK);
427 ret = LnnSetLocalNumInfo(NUM_KEY_P2P_ROLE, P2P_ROLE);
428 EXPECT_TRUE(ret == SOFTBUS_OK);
429 ret = LnnSetLocalNumInfo(NUM_KEY_STATIC_CAP_LEN, STATIC_LEN);
430 EXPECT_TRUE(ret == SOFTBUS_OK);
431 LnnDeinitLocalLedger();
432 }
433
434 /*
435 * @tc.name: LOCAL_LEDGER_Test_005
436 * @tc.desc: lnn local key table test
437 * @tc.type: FUNC
438 * @tc.require:
439 */
440 HWTEST_F(LNNNetLedgerCommonTest, LOCAL_LEDGER_Test_005, TestSize.Level1)
441 {
442 int64_t info;
443 EXPECT_TRUE(LnnInitLocalLedger() == SOFTBUS_OK);
444 int32_t ret = LnnGetLocalNum64Info(NUM_KEY_TRANS_PROTOCOLS, &info);
445 EXPECT_TRUE(ret == SOFTBUS_OK);
446 ret = LnnGetLocalDeviceInfo(nullptr);
447 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
448 EXPECT_TRUE(LnnIsMasterNode() == false);
449 LnnDeinitLocalLedger();
450 LnnDeinitLocalLedger();
451 }
452 } // namespace OHOS