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 "lnn_distributed_net_ledger.h"
17
18 #include <gtest/gtest.h>
19 #include <securec.h>
20 #include <cstddef>
21 #include <cstdlib>
22 #include <cstring>
23
24 #include "lnn_connection_addr_utils.h"
25 #include "lnn_fast_offline.h"
26 #include "lnn_log.h"
27 #include "lnn_map.h"
28 #include "lnn_node_info.h"
29 #include "softbus_adapter_mem.h"
30 #include "softbus_adapter_thread.h"
31 #include "softbus_bus_center.h"
32 #include "softbus_errcode.h"
33 #include "softbus_utils.h"
34 #include "softbus_hidumper_buscenter.h"
35 #include "bus_center_manager.h"
36 #include "lnn_distributed_net_ledger.c"
37 #include "lnn_distributed_net_ledger_manager.c"
38 #include <cstring>
39
40 namespace OHOS {
41 using namespace testing::ext;
42 constexpr char NODE1_DEVICE_NAME[] = "node1_test";
43 constexpr char NODE1_UDID[] = "123456ABCDEF";
44 constexpr char NODE1_NETWORK_ID[] = "235689BNHFCF";
45 constexpr char NODE1_UUID[] = "235689BNHFCC";
46 constexpr char NODE1_BT_MAC[] = "56789TTU";
47 constexpr char NODE2_DEVICE_NAME[] = "node2_test";
48 constexpr char NODE2_UDID[] = "123456ABCDEG";
49 constexpr char NODE2_NETWORK_ID[] = "235689BNHFCG";
50 constexpr char NODE2_UUID[] = "235689BNHFCD";
51 constexpr char NODE2_BT_MAC[] = "56789TYU";
52 constexpr char P2P_MAC[] = "11:22:33:44:55";
53 constexpr char GO_MAC[] = "22:33:44:55:66";
54 constexpr int32_t P2P_ROLE = 1;
55 constexpr uint32_t DISCOVERY_TYPE = 62;
56 constexpr int32_t AUTH_ID = 10;
57 constexpr uint64_t TIME_STAMP = 5000;
58 constexpr uint64_t CAPABILITY = 62;
59 constexpr uint64_t NEW_TIME_STAMP = 6000;
60 constexpr int64_t AUTH_SEQ = 1;
61 constexpr char NODE_ADDRESS[] = "address";
62 constexpr char RECV_UDID_HASH[] = "87654321";
63 using namespace testing;
64 class LNNDisctributedLedgerTest : public testing::Test {
65 public:
66 static void SetUpTestCase();
67 static void TearDownTestCase();
68 void SetUp();
69 void TearDown();
70 };
71
TestFunc(NodeBasicInfo * info)72 void TestFunc(NodeBasicInfo *info)
73 {
74 (void)info;
75 return;
76 }
77
SetUpTestCase()78 void LNNDisctributedLedgerTest::SetUpTestCase()
79 {
80 }
81
TearDownTestCase()82 void LNNDisctributedLedgerTest::TearDownTestCase()
83 {
84 }
85
SetUp()86 void LNNDisctributedLedgerTest::SetUp()
87 {
88 LNN_LOGI(LNN_TEST, "LocalLedgerTest start");
89 int32_t ret = LnnInitDistributedLedger();
90 EXPECT_TRUE(ret == SOFTBUS_OK);
91 NodeInfo info;
92 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
93 info.discoveryType = DISCOVERY_TYPE;
94 (void)strncpy_s(info.uuid, UUID_BUF_LEN, NODE1_UUID, strlen(NODE1_UUID));
95 (void)strncpy_s(info.deviceInfo.deviceUdid, UDID_BUF_LEN, NODE1_UDID, strlen(NODE1_UDID));
96 (void)strncpy_s(info.networkId, NETWORK_ID_BUF_LEN, NODE1_NETWORK_ID, strlen(NODE1_NETWORK_ID));
97 (void)strncpy_s(info.connectInfo.macAddr, MAC_LEN, NODE1_BT_MAC, strlen(NODE1_BT_MAC));
98 info.authSeq[0] = AUTH_SEQ;
99 info.heartbeatTimeStamp = TIME_STAMP;
100 EXPECT_TRUE(REPORT_ONLINE == LnnAddOnlineNode(&info));
101 }
102
TearDown()103 void LNNDisctributedLedgerTest::TearDown()
104 {
105 LNN_LOGI(LNN_TEST, "LocalLedgerTest end");
106 LnnDeinitDistributedLedger();
107 }
108
109 /*
110 * @tc.name: LNN_ADD_ONLINE_NODE_Test_001
111 * @tc.desc: lnn add online node test
112 * @tc.type: FUNC
113 * @tc.require:
114 */
115 HWTEST_F(LNNDisctributedLedgerTest, LNN_ADD_ONLINE_NODE_Test_001, TestSize.Level1)
116 {
117 NodeInfo info;
118 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
119 info.discoveryType = DISCOVERY_TYPE;
120 (void)strncpy_s(info.uuid, UUID_BUF_LEN, NODE1_UUID, strlen(NODE1_UUID));
121 (void)strncpy_s(info.deviceInfo.deviceUdid, UDID_BUF_LEN, NODE1_UDID, strlen(NODE1_UDID));
122 (void)strncpy_s(info.networkId, NETWORK_ID_BUF_LEN, NODE1_NETWORK_ID, strlen(NODE1_NETWORK_ID));
123 (void)strncpy_s(info.connectInfo.macAddr, MAC_LEN, NODE1_BT_MAC, strlen(NODE1_BT_MAC));
124 EXPECT_TRUE(REPORT_NONE == LnnAddOnlineNode(&info));
125 }
126
127 /*
128 * @tc.name: LNN_GET_REMOTE_STRINFO_Test_001
129 * @tc.desc: lnn get remote strInfo test
130 * @tc.type: FUNC
131 * @tc.require:
132 */
133 HWTEST_F(LNNDisctributedLedgerTest, LNN_GET_REMOTE_STRINFO_Test_001, TestSize.Level1)
134 {
135 static InfoKey keyStringTable[] = {
136 STRING_KEY_HICE_VERSION,
137 STRING_KEY_DEV_UDID,
138 STRING_KEY_UUID,
139 STRING_KEY_DEV_TYPE,
140 STRING_KEY_DEV_NAME,
141 STRING_KEY_BT_MAC,
142 STRING_KEY_WLAN_IP,
143 STRING_KEY_MASTER_NODE_UDID,
144 STRING_KEY_P2P_MAC,
145 STRING_KEY_P2P_GO_MAC,
146 STRING_KEY_NODE_ADDR,
147 STRING_KEY_OFFLINE_CODE,
148 STRING_KEY_WIFIDIRECT_ADDR
149 };
150 char buf[UDID_BUF_LEN] = {0};
151 int32_t ret = LnnGetRemoteStrInfo(nullptr, STRING_KEY_HICE_VERSION, buf, UDID_BUF_LEN);
152 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
153 ret = LnnGetRemoteStrInfo(NODE1_NETWORK_ID, STRING_KEY_HICE_VERSION, nullptr, UDID_BUF_LEN);
154 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
155 ret = LnnGetRemoteStrInfo(NODE1_NETWORK_ID, NUM_KEY_BEGIN, buf, UDID_BUF_LEN);
156 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
157 uint32_t i;
158 for (i = 0; i < sizeof(keyStringTable) / sizeof(InfoKey); i++) {
159 (void)memset_s(buf, UDID_BUF_LEN, 0, UDID_BUF_LEN);
160 ret = LnnGetRemoteStrInfo(NODE1_NETWORK_ID, keyStringTable[i], buf, UDID_BUF_LEN);
161 EXPECT_TRUE(ret == SOFTBUS_OK);
162 }
163 for (i = 0; i < sizeof(keyStringTable) / sizeof(InfoKey); i++) {
164 ret = LnnGetRemoteStrInfo(NODE2_NETWORK_ID, keyStringTable[i], buf, UDID_BUF_LEN);
165 EXPECT_TRUE(ret == SOFTBUS_ERR);
166 }
167 }
168
169 /*
170 * @tc.name: LNN_GET_REMOTE_NUMNFO_Test_002
171 * @tc.desc: lnn get remote num info test
172 * @tc.type: FUNC
173 * @tc.require:
174 */
175 HWTEST_F(LNNDisctributedLedgerTest, LNN_GET_REMOTE_NUMNFO_Test_002, TestSize.Level1)
176 {
177 static InfoKey keyNumTable[] = {
178 NUM_KEY_META_NODE,
179 NUM_KEY_SESSION_PORT,
180 NUM_KEY_AUTH_PORT,
181 NUM_KEY_PROXY_PORT,
182 NUM_KEY_NET_CAP,
183 NUM_KEY_DISCOVERY_TYPE,
184 NUM_KEY_MASTER_NODE_WEIGHT,
185 NUM_KEY_P2P_ROLE
186 };
187 int32_t ret;
188 uint32_t i;
189 int32_t len = LNN_COMMON_LEN;
190 for (i = 0; i < sizeof(keyNumTable) / sizeof(InfoKey); i++) {
191 ret = LnnGetRemoteNumInfo(NODE1_NETWORK_ID, keyNumTable[i], &len);
192 EXPECT_TRUE(ret == SOFTBUS_OK);
193 }
194 for (i = 0; i < sizeof(keyNumTable) / sizeof(InfoKey); i++) {
195 ret = LnnGetRemoteNumInfo(NODE2_NETWORK_ID, keyNumTable[i], &len);
196 EXPECT_TRUE(ret == SOFTBUS_ERR);
197 }
198 }
199
200 /*
201 * @tc.name: LNN_GET_REMOTE_BYTEINFO_Test_003
202 * @tc.desc: lnn get remote byte info test
203 * @tc.type: FUNC
204 * @tc.require:
205 */
206 HWTEST_F(LNNDisctributedLedgerTest, LNN_GET_REMOTE_BYTEINFO_Test_003, TestSize.Level1)
207 {
208 unsigned char irk[LFINDER_IRK_LEN] = {0};
209 int32_t ret = LnnGetRemoteByteInfo(nullptr, BYTE_KEY_IRK, irk, LFINDER_IRK_LEN);
210 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
211 ret = LnnGetRemoteByteInfo(NODE1_NETWORK_ID, BYTE_KEY_IRK, nullptr, LFINDER_IRK_LEN);
212 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
213 ret = LnnGetRemoteByteInfo(NODE1_NETWORK_ID, BYTE_KEY_IRK, irk, LFINDER_IRK_LEN);
214 EXPECT_EQ(SOFTBUS_OK, ret);
215
216 unsigned char pubMac[LFINDER_MAC_ADDR_LEN] = {0};
217 ret = LnnGetRemoteByteInfo(nullptr, BYTE_KEY_PUB_MAC, pubMac, LFINDER_MAC_ADDR_LEN);
218 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
219 ret = LnnGetRemoteByteInfo(NODE1_NETWORK_ID, BYTE_KEY_PUB_MAC, nullptr, LFINDER_MAC_ADDR_LEN);
220 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
221 ret = LnnGetRemoteByteInfo(NODE1_NETWORK_ID, BYTE_KEY_PUB_MAC, pubMac, LFINDER_MAC_ADDR_LEN);
222 EXPECT_EQ(SOFTBUS_OK, ret);
223
224 unsigned char cipherKey[SESSION_KEY_LENGTH] = {0};
225 ret = LnnGetRemoteByteInfo(nullptr, BYTE_KEY_BROADCAST_CIPHER_KEY, cipherKey, SESSION_KEY_LENGTH);
226 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
227 ret = LnnGetRemoteByteInfo(NODE1_NETWORK_ID, BYTE_KEY_BROADCAST_CIPHER_KEY, nullptr, SESSION_KEY_LENGTH);
228 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
229 ret = LnnGetRemoteByteInfo(NODE1_NETWORK_ID, BYTE_KEY_BROADCAST_CIPHER_KEY, cipherKey, SESSION_KEY_LENGTH);
230 EXPECT_EQ(SOFTBUS_OK, ret);
231
232 unsigned char cipherIv[BROADCAST_IV_LEN] = {0};
233 ret = LnnGetRemoteByteInfo(nullptr, BYTE_KEY_BROADCAST_CIPHER_IV, cipherIv, BROADCAST_IV_LEN);
234 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
235 ret = LnnGetRemoteByteInfo(NODE1_NETWORK_ID, BYTE_KEY_BROADCAST_CIPHER_IV, nullptr, BROADCAST_IV_LEN);
236 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
237 ret = LnnGetRemoteByteInfo(NODE1_NETWORK_ID, BYTE_KEY_BROADCAST_CIPHER_IV, cipherIv, BROADCAST_IV_LEN);
238 EXPECT_EQ(SOFTBUS_OK, ret);
239 }
240
241 /*
242 * @tc.name: LNN_GET_CNN_CODE_Test_001
243 * @tc.desc: lnn get cnn code test
244 * @tc.type: FUNC
245 * @tc.require:
246 */
247 HWTEST_F(LNNDisctributedLedgerTest, LNN_GET_CNN_CODE_Test_001, TestSize.Level1)
248 {
249 DiscoveryType type = DISCOVERY_TYPE_WIFI;
250 short ret = LnnGetCnnCode(nullptr, type);
251 EXPECT_TRUE(ret == INVALID_CONNECTION_CODE_VALUE);
252 ret = LnnGetCnnCode(NODE1_UUID, type);
253 EXPECT_TRUE(ret == INVALID_CONNECTION_CODE_VALUE);
254 ret = LnnGetCnnCode(NODE2_UUID, type);
255 EXPECT_TRUE(ret == INVALID_CONNECTION_CODE_VALUE);
256 }
257
258 /*
259 * @tc.name: LNN_UPDATE_NODE_INFO_Test_001
260 * @tc.desc: lnn update node info test
261 * @tc.type: FUNC
262 * @tc.require:
263 */
264 HWTEST_F(LNNDisctributedLedgerTest, LNN_UPDATE_NODE_INFO_Test_001, TestSize.Level1)
265 {
266 NodeInfo newInfo;
267 (void)memset_s(&newInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
268 (void)strncpy_s(newInfo.deviceInfo.deviceUdid, UDID_BUF_LEN, NODE1_UDID, strlen(NODE1_UDID));
269 int32_t ret = LnnUpdateNodeInfo(&newInfo);
270 EXPECT_TRUE(ret == SOFTBUS_OK);
271 (void)memset_s(&newInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
272 (void)strncpy_s(newInfo.deviceInfo.deviceUdid, UDID_BUF_LEN, NODE2_UDID, strlen(NODE2_UDID));
273 ret = LnnUpdateNodeInfo(&newInfo);
274 EXPECT_TRUE(ret == SOFTBUS_ERR);
275 }
276
277 /*
278 * @tc.name: LNN_SET_NODE_OFFLINE_Test_001
279 * @tc.desc: lnn set node offline test
280 * @tc.type: FUNC
281 * @tc.require:
282 */
283 HWTEST_F(LNNDisctributedLedgerTest, LNN_SET_NODE_OFFLINE_Test_001, TestSize.Level1)
284 {
285 EXPECT_TRUE(REPORT_NONE == LnnSetNodeOffline(NODE1_UDID, CONNECTION_ADDR_WLAN, AUTH_ID));
286 EXPECT_TRUE(REPORT_NONE == LnnSetNodeOffline(NODE2_UDID, CONNECTION_ADDR_WLAN, AUTH_ID));
287 DfxRecordLnnSetNodeOfflineEnd(NODE1_UDID, 1, SOFTBUS_OK);
288 }
289
290 /*
291 * @tc.name: LNN_GET_BASIC_INFO_BY_UDID_Test_001
292 * @tc.desc: lnn get basic info by udid test
293 * @tc.type: FUNC
294 * @tc.require:
295 */
296 HWTEST_F(LNNDisctributedLedgerTest, LNN_GET_BASIC_INFO_BY_UDID_Test_001, TestSize.Level1)
297 {
298 NodeBasicInfo basicInfo;
299 (void)memset_s(&basicInfo, sizeof(NodeBasicInfo), 0, sizeof(NodeBasicInfo));
300 int32_t ret = LnnGetBasicInfoByUdid(NODE1_UDID, nullptr);
301 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
302 ret = LnnGetBasicInfoByUdid(NODE1_UDID, &basicInfo);
303 EXPECT_TRUE(ret == SOFTBUS_OK);
304 }
305
306 /*
307 * @tc.name: LNN_CONVERT_DLID_Test_001
308 * @tc.desc: lnn convert dl id test
309 * @tc.type: FUNC
310 * @tc.require:
311 */
312
313 HWTEST_F(LNNDisctributedLedgerTest, LNN_CONVERT_DLID_Test_001, TestSize.Level1)
314 {
315 char buf[UDID_BUF_LEN] = {0};
316 int32_t ret = LnnConvertDlId(nullptr, CATEGORY_UDID, CATEGORY_UDID, buf, UDID_BUF_LEN);
317 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
318 ret = LnnConvertDlId(NODE1_UDID, CATEGORY_UDID, CATEGORY_UDID, buf, UDID_BUF_LEN);
319 EXPECT_TRUE(ret == SOFTBUS_OK);
320 ret = LnnConvertDlId(NODE2_UDID, CATEGORY_UDID, CATEGORY_UDID, buf, UDID_BUF_LEN);
321 EXPECT_TRUE(ret == SOFTBUS_NOT_FIND);
322 ret = LnnConvertDlId(NODE2_UUID, CATEGORY_UUID, CATEGORY_UUID, buf, UDID_BUF_LEN);
323 EXPECT_TRUE(ret == SOFTBUS_NOT_FIND);
324 ret = LnnConvertDlId(NODE2_NETWORK_ID, CATEGORY_NETWORK_ID, CATEGORY_NETWORK_ID, buf, NETWORK_ID_BUF_LEN);
325 EXPECT_TRUE(ret == SOFTBUS_NOT_FIND);
326 }
327
328 /*
329 * @tc.name: LNN_SET_DLP2P_INFO_Test_001
330 * @tc.desc: lnn get lnn relation test
331 * @tc.type: FUNC
332 * @tc.require:
333 */
334 HWTEST_F(LNNDisctributedLedgerTest, LNN_SET_DLP2P_INFO_Test_001, TestSize.Level1)
335 {
336 P2pInfo info;
337 (void)memset_s(&info, sizeof(P2pInfo), 0, sizeof(P2pInfo));
338 (void)strncpy_s(info.p2pMac, MAC_LEN, P2P_MAC, strlen(P2P_MAC));
339 (void)strncpy_s(info.goMac, MAC_LEN, GO_MAC, strlen(GO_MAC));
340 info.p2pRole = P2P_ROLE;
341 bool ret = LnnSetDLP2pInfo(nullptr, &info);
342 EXPECT_TRUE(ret == false);
343 ret = LnnSetDLP2pInfo(NODE1_NETWORK_ID, &info);
344 EXPECT_TRUE(ret == true);
345 ret = LnnSetDLP2pInfo(NODE2_NETWORK_ID, &info);
346 EXPECT_TRUE(ret == false);
347 }
348
349 /*
350 * @tc.name: LNN_GET_NETWORKID_BYBTMAC_Test_001
351 * @tc.desc: lnn get neteorkId by bt mac test
352 * @tc.type: FUNC
353 * @tc.require:
354 */
355 HWTEST_F(LNNDisctributedLedgerTest, LNN_GET_NETWORKID_BYBTMAC_Test_001, TestSize.Level1)
356 {
357 char buf[NETWORK_ID_BUF_LEN] = {0};
358 int32_t ret = LnnGetNetworkIdByBtMac(nullptr, buf, NETWORK_ID_BUF_LEN);
359 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
360 ret = LnnGetNetworkIdByBtMac(NODE1_BT_MAC, buf, NETWORK_ID_BUF_LEN);
361 EXPECT_TRUE(ret == SOFTBUS_OK);
362 ret = LnnGetNetworkIdByBtMac(NODE2_BT_MAC, buf, NETWORK_ID_BUF_LEN);
363 EXPECT_TRUE(ret != SOFTBUS_OK);
364 }
365
366 /*
367 * @tc.name: LNN_GET_NETWORKID_BY_UUID_Test_001
368 * @tc.desc: lnn get neteorkId by uuid test
369 * @tc.type: FUNC
370 * @tc.require:
371 */
372 HWTEST_F(LNNDisctributedLedgerTest, LNN_GET_NETWORKID_BY_UUID_Test_001, TestSize.Level1)
373 {
374 char buf[UUID_BUF_LEN] = {0};
375 int32_t ret = LnnGetNetworkIdByUuid(nullptr, buf, UUID_BUF_LEN);
376 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
377 ret = LnnGetNetworkIdByUuid(NODE1_UUID, buf, NETWORK_ID_BUF_LEN);
378 EXPECT_TRUE(ret == SOFTBUS_OK);
379 ret = LnnGetNetworkIdByUuid(NODE2_UUID, buf, NETWORK_ID_BUF_LEN);
380 EXPECT_TRUE(ret != SOFTBUS_OK);
381 }
382
383 /*
384 * @tc.name: LNN_GET_NETWORKID_BY_UDID_Test_001
385 * @tc.desc: lnn get neteorkId by udid test
386 * @tc.type: FUNC
387 * @tc.require:
388 */
389 HWTEST_F(LNNDisctributedLedgerTest, LNN_GET_NETWORKID_BY_UDID_Test_001, TestSize.Level1)
390 {
391 char buf[UDID_BUF_LEN] = {0};
392 int32_t ret = LnnGetNetworkIdByUdid(nullptr, buf, UDID_BUF_LEN);
393 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
394 ret = LnnGetNetworkIdByUdid(NODE1_UDID, buf, UDID_BUF_LEN);
395 EXPECT_TRUE(ret == SOFTBUS_OK);
396 ret = LnnGetNetworkIdByUdid(NODE2_UDID, buf, UDID_BUF_LEN);
397 EXPECT_TRUE(ret != SOFTBUS_OK);
398 }
399
400 /*
401 * @tc.name: LNN_GET_DLHEARTBEAT_TIMER_STAMP_Test_001
402 * @tc.desc: lnn get dl heartbeat time stamp test
403 * @tc.type: FUNC
404 * @tc.require:
405 */
406 HWTEST_F(LNNDisctributedLedgerTest, LNN_GET_DLHEARTBEAT_TIMER_STAMP_Test_001, TestSize.Level1)
407 {
408 uint64_t timeStamp;
409 int32_t ret = LnnGetDLHeartbeatTimestamp(NODE1_NETWORK_ID, &timeStamp);
410 EXPECT_TRUE(ret == SOFTBUS_OK);
411 ret = LnnGetDLHeartbeatTimestamp(NODE2_NETWORK_ID, &timeStamp);
412 EXPECT_TRUE(ret != SOFTBUS_OK);
413 }
414
415 /*
416 * @tc.name: LNN_SET_DLHEARTBEAT_TIMER_STAMP_Test_001
417 * @tc.desc: lnn set dl heartbeat time stamp test
418 * @tc.type: FUNC
419 * @tc.require:
420 */
421 HWTEST_F(LNNDisctributedLedgerTest, LNN_SET_DLHEARTBEAT_TIMER_STAMP_Test_001, TestSize.Level1)
422 {
423 uint64_t timeStamp = NEW_TIME_STAMP;
424 int32_t ret = LnnSetDLHeartbeatTimestamp(NODE1_NETWORK_ID, timeStamp);
425 EXPECT_TRUE(ret == SOFTBUS_OK);
426 ret = LnnSetDLHeartbeatTimestamp(NODE2_NETWORK_ID, timeStamp);
427 EXPECT_TRUE(ret != SOFTBUS_OK);
428 }
429
430 /*
431 * @tc.name: LNN_SET_DLCONN_CAPABILITY_Test_001
432 * @tc.desc: lnn set dl conn capability test
433 * @tc.type: FUNC
434 * @tc.require:
435 */
436 HWTEST_F(LNNDisctributedLedgerTest, LNN_SET_DLCONN_CAPABILITY_Test_001, TestSize.Level1)
437 {
438 uint64_t connCapability = CAPABILITY;
439 int32_t ret = LnnSetDLConnCapability(NODE2_NETWORK_ID, connCapability);
440 EXPECT_TRUE(ret != SOFTBUS_OK);
441 }
442
443 /*
444 * @tc.name: LNN_SET_DLNODE_ADDR_Test_001
445 * @tc.desc: lnn set dl node addr test
446 * @tc.type: FUNC
447 * @tc.require:
448 */
449 HWTEST_F(LNNDisctributedLedgerTest, LNN_SET_DLNODE_ADDR_Test_001, TestSize.Level1)
450 {
451 int32_t ret = LnnSetDLNodeAddr(NODE1_NETWORK_ID, CATEGORY_NETWORK_ID, NODE_ADDRESS);
452 EXPECT_TRUE(ret == SOFTBUS_OK);
453 ret = LnnSetDLNodeAddr(NODE2_NETWORK_ID, CATEGORY_NETWORK_ID, NODE_ADDRESS);
454 EXPECT_TRUE(ret != SOFTBUS_OK);
455 }
456
457 /*
458 * @tc.name: LNN_GET_ONLINE_NODE_BY_UDID_HASH_Test_001
459 * @tc.desc: lnn get online node by udid hash test
460 * @tc.type: FUNC
461 * @tc.require:
462 */
463 HWTEST_F(LNNDisctributedLedgerTest, LNN_GET_ONLINE_NODE_BY_UDID_HASH_Test_001, TestSize.Level1)
464 {
465 EXPECT_TRUE(LnnGetOnlineNodeByUdidHash(RECV_UDID_HASH) == nullptr);
466 }
467
468 /*
469 * @tc.name: LNN_GET_DATA_CHANGE_FLAG_Test_001
470 * @tc.desc: lnn get data change flag test
471 * @tc.type: FUNC
472 * @tc.require:
473 */
474 HWTEST_F(LNNDisctributedLedgerTest, LNN_GET_DATA_CHANGE_FLAG_Test_001, TestSize.Level1)
475 {
476 int16_t info = 0;
477 int32_t ret = LnnGetRemoteNum16Info(NODE1_NETWORK_ID, NUM_KEY_DATA_CHANGE_FLAG, &info);
478 EXPECT_TRUE(ret == SOFTBUS_OK);
479 ret = LnnGetRemoteNum16Info(NODE2_NETWORK_ID, NUM_KEY_DATA_CHANGE_FLAG, &info);
480 EXPECT_TRUE(ret == SOFTBUS_ERR);
481 ret = LnnGetRemoteNum16Info(NODE2_NETWORK_ID, NUM_KEY_DATA_CHANGE_FLAG, nullptr);
482 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
483 }
484
485 /*
486 * @tc.name: LNN_CONVERT_DLID_TO_UDID_Test_001
487 * @tc.desc: lnn convert dlid to udid test
488 * @tc.type: FUNC
489 * @tc.require:
490 */
491 HWTEST_F(LNNDisctributedLedgerTest, LNN_CONVERT_DLID_TO_UDID_Test_001, TestSize.Level1)
492 {
493 EXPECT_TRUE(LnnConvertDLidToUdid(nullptr, CATEGORY_NETWORK_ID) == nullptr);
494 LnnConvertDLidToUdid(NODE1_NETWORK_ID, CATEGORY_NETWORK_ID);
495 EXPECT_TRUE(LnnConvertDLidToUdid(NODE2_NETWORK_ID, CATEGORY_NETWORK_ID) == nullptr);
496 }
497
498 /*
499 * @tc.name: LNN_GET_LNN_RELATION_Test_001
500 * @tc.desc: lnn get lnn relation test
501 * @tc.type: FUNC
502 * @tc.require:
503 */
504 HWTEST_F(LNNDisctributedLedgerTest, LNN_GET_LNN_RELATION_Test_001, TestSize.Level1)
505 {
506 uint8_t relation[CONNECTION_ADDR_MAX] = {0};
507 int32_t ret = LnnGetLnnRelation(nullptr, CATEGORY_UDID, relation, CONNECTION_ADDR_MAX);
508 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
509 ret = LnnGetLnnRelation(NODE1_UDID, CATEGORY_UDID, relation, CONNECTION_ADDR_MAX);
510 EXPECT_TRUE(ret == SOFTBUS_OK);
511 ret = LnnGetLnnRelation(NODE2_UDID, CATEGORY_UDID, relation, CONNECTION_ADDR_MAX);
512 EXPECT_TRUE(ret == SOFTBUS_NOT_FIND);
513 }
514
515 /*
516 * @tc.name: LNN_SET_DL_DEVICE_INFO_NAME_Test_001
517 * @tc.desc: lnn set dl device info name test
518 * @tc.type: FUNC
519 * @tc.require:
520 */
521 HWTEST_F(LNNDisctributedLedgerTest, LNN_SET_DL_DEVICE_INFO_NAME_Test_001, TestSize.Level1)
522 {
523 bool ret = LnnSetDLDeviceInfoName(nullptr, nullptr);
524 EXPECT_TRUE(ret == false);
525 ret = LnnSetDLDeviceInfoName(NODE1_UDID, NODE1_DEVICE_NAME);
526 EXPECT_TRUE(ret == true);
527 ret = LnnSetDLDeviceInfoName(NODE2_UDID, NODE2_DEVICE_NAME);
528 EXPECT_TRUE(ret == false);
529 }
530
531 HWTEST_F(LNNDisctributedLedgerTest, GET_NODEINFO_FORMMAP_Test_001, TestSize.Level1)
532 {
533 (void)GetCurrentTime();
534 NodeInfo *res = GetNodeInfoFromMap(nullptr, nullptr);
535 EXPECT_TRUE(res == nullptr);
536 }
537
538 HWTEST_F(LNNDisctributedLedgerTest, INIT_DISTRIBUTED_INFO_Test_001, TestSize.Level1)
539 {
540 int32_t ret = InitDistributedInfo(nullptr);
541 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
542 ret = InitConnectionCode(nullptr);
543 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
544 (void)DeinitConnectionCode(nullptr);
545 }
546
547 HWTEST_F(LNNDisctributedLedgerTest, NEW_BRBLE_DISCOVERED_Test_001, TestSize.Level1)
548 {
549 NodeInfo oldInfo;
550 NodeInfo newInfo;
551 (void)NewWifiDiscovered(nullptr, nullptr);
552 (void)NewWifiDiscovered(&oldInfo, &newInfo);
553 (void)NewBrBleDiscovered(nullptr, nullptr);
554 (void)NewBrBleDiscovered(&oldInfo, &newInfo);
555 (void)RetainOfflineCode(nullptr, nullptr);
556 (void)ConvertNodeInfoToBasicInfo(nullptr, nullptr);
557 bool ret = IsNetworkIdChanged(nullptr, nullptr);
558 EXPECT_TRUE(ret == false);
559 ret = IsNetworkIdChanged(&newInfo, &oldInfo);
560 EXPECT_TRUE(ret == false);
561 }
562
563 HWTEST_F(LNNDisctributedLedgerTest, IS_META_NODE_Test_001, TestSize.Level1)
564 {
565 NodeInfo info;
566 info.metaInfo.isMetaNode = true;
567 bool ret = IsMetaNode(nullptr);
568 EXPECT_TRUE(ret == false);
569 ret = IsMetaNode(&info);
570 EXPECT_TRUE(ret == true);
571 }
572
573 HWTEST_F(LNNDisctributedLedgerTest, LNN_GET_NODEINFO_BYID_Test_001, TestSize.Level1)
574 {
575 INodeStateCb callBack;
576 IdCategory type = CATEGORY_UDID;
577 NodeInfo *ret = LnnGetNodeInfoById(nullptr, type);
578 EXPECT_TRUE(ret == nullptr);
579 callBack.onNodeOnline = nullptr;
580 (void)PostOnlineNodesToCb(&callBack);
581 callBack.onNodeOnline = TestFunc;
582 (void)PostOnlineNodesToCb(&callBack);
583 }
584
585 HWTEST_F(LNNDisctributedLedgerTest, LNN_GET_REMOTE_NODE_Test_001, TestSize.Level1)
586 {
587 int32_t ret = LnnGetRemoteNodeInfoByKey(nullptr, nullptr);
588 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
589 const char *key = "dsoftBus";
590 NodeInfo info;
591 ret = LnnGetRemoteNodeInfoByKey(key, &info);
592 EXPECT_TRUE(ret != SOFTBUS_OK);
593 }
594
595 HWTEST_F(LNNDisctributedLedgerTest, DLGET_DEVICE_TYPEID_Test_001, TestSize.Level1)
596 {
597 const char *networkId = "softBus";
598 char bleMac = '0';
599 uint32_t len = 0;
600 int32_t ret = DlGetDeviceTypeId(nullptr, true, nullptr, len);
601 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
602 ret = DlGetNodeBleMac(nullptr, true, nullptr, len);
603 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
604 (void)LnnUpdateNodeBleMac(nullptr, nullptr, len);
605 (void)LnnUpdateNodeBleMac(networkId, &bleMac, len);
606 }
607
608 HWTEST_F(LNNDisctributedLedgerTest, DL_GET_WIFICFG_Test_001, TestSize.Level1)
609 {
610 uint32_t len = 0;
611 int32_t ret = DlGetWifiCfg(nullptr, true, nullptr, len);
612 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
613 ret = DlGetChanList5g(nullptr, true, nullptr, len);
614 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
615 ret = DlGetP2pRole(nullptr, true, nullptr, len);
616 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
617 ret = DlGetStateVersion(nullptr, true, nullptr, len);
618 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
619 ret = DlGetStaFrequency(nullptr, true, nullptr, len);
620 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
621 len = LNN_COMMON_LEN;
622 ret = DlGetStateVersion(nullptr, true, nullptr, len);
623 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
624 ret = DlGetStaFrequency(nullptr, true, nullptr, len);
625 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
626 ret = DlGetNodeDataChangeFlag(nullptr, true, nullptr, len);
627 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
628 len = DATA_CHANGE_FLAG_BUF_LEN;
629 ret = DlGetNodeDataChangeFlag(nullptr, true, nullptr, len);
630 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
631 ret = DlGetMasterWeight(nullptr, true, nullptr, len);
632 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
633 ret = DlGetNetType(nullptr, true, nullptr, len);
634 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
635 ret = DlGetProxyPort(nullptr, true, nullptr, len);
636 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
637 ret = DlGetSessionPort(nullptr, true, nullptr, len);
638 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
639 ret = DlGetAuthPort(nullptr, true, nullptr, len);
640 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
641 }
642
643 HWTEST_F(LNNDisctributedLedgerTest, DLGET_NODETTLV_NEGOFLAG_Test_001, TestSize.Level1)
644 {
645 uint32_t len = 0;
646 int32_t ret = DlGetNodeTlvNegoFlag(nullptr, true, nullptr, len);
647 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
648 ret = DlGetAccountHash(nullptr, true, nullptr, len);
649 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
650 len = sizeof(bool);
651 ret = DlGetNodeTlvNegoFlag(nullptr, true, nullptr, len);
652 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
653 len = SHA_256_HASH_LEN;
654 ret = DlGetAccountHash(nullptr, true, nullptr, len);
655 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
656 (void)DestroyCnnCodeKey(nullptr);
657 (void)DeinitDistributedInfo(nullptr);
658 }
659
660 HWTEST_F(LNNDisctributedLedgerTest, ADD_CNN_CODE_Test_001, TestSize.Level1)
661 {
662 Map cnnCode;
663 const char *uuid = "softBus";
664 DiscoveryType type = DISCOVERY_TYPE_WIFI;
665 int64_t authSeqNum = 0;
666 int32_t ret = AddCnnCode(&cnnCode, nullptr, type, authSeqNum);
667 EXPECT_TRUE(ret == SOFTBUS_ERR);
668 ret = AddCnnCode(&cnnCode, uuid, type, authSeqNum);
669 EXPECT_TRUE(ret == SOFTBUS_OK);
670
671 char *key = CreateCnnCodeKey(uuid, type);
672 EXPECT_NE(key, nullptr);
673 short* code = (short *)LnnMapGet(&cnnCode, key);
674 EXPECT_NE(code, nullptr);
675
676 (void)RemoveCnnCode(&cnnCode, nullptr, type);
677 (void)RemoveCnnCode(&cnnCode, uuid, type);
678
679 code = (short *)LnnMapGet(&cnnCode, key);
680 EXPECT_EQ(code, nullptr);
681 DestroyCnnCodeKey(key);
682 }
683
684 HWTEST_F(LNNDisctributedLedgerTest, NOTIFY_MIGRATE_UPGRADE_Test_001, TestSize.Level1)
685 {
686 NodeInfo info;
687 memset_s(info.deviceInfo.deviceUdid, sizeof(info.deviceInfo.deviceUdid), '\0', sizeof(info.deviceInfo.deviceUdid));
688 (void)NotifyMigrateUpgrade(&info);
689 int32_t ret = LnnUpdateAccountInfo(nullptr);
690 EXPECT_TRUE(ret != SOFTBUS_OK);
691 }
692
693 HWTEST_F(LNNDisctributedLedgerTest, LNN_UPDATE_GROUPTYPE_Test_001, TestSize.Level1)
694 {
695 NodeInfo info;
696 int32_t ret = LnnUpdateGroupType(nullptr);
697 EXPECT_TRUE(ret != SOFTBUS_OK);
698 char str[] = "softBus";
699 strcpy_s(info.deviceInfo.deviceUdid, sizeof(str), str);
700 ret = LnnUpdateGroupType(&info);
701 EXPECT_TRUE(ret == SOFTBUS_ERR);
702
703 const char *udid = "softBus";
704 (void)NotifyMigrateDegrade(udid);
705 }
706
707 HWTEST_F(LNNDisctributedLedgerTest, LNN_GET_REMOTE_BYTEINFO_Test_001, TestSize.Level1)
708 {
709 const char *networkId = "softBus";
710 InfoKey key = BYTE_KEY_END;
711 uint8_t info;
712 uint32_t len = 0;
713 int32_t ret = LnnGetRemoteByteInfo(nullptr, key, &info, len);
714 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
715 ret = LnnGetRemoteByteInfo(networkId, key, nullptr, len);
716 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
717 ret = LnnGetRemoteByteInfo(networkId, key, &info, len);
718 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
719 key = BYTE_KEY_BEGIN;
720 ret = LnnGetRemoteByteInfo(networkId, key, &info, len);
721 EXPECT_TRUE(ret != SOFTBUS_OK);
722 }
723
724 HWTEST_F(LNNDisctributedLedgerTest, LNN_ISLSA_NODE_Test_001, TestSize.Level1)
725 {
726 NodeBasicInfo info;
727 memset_s(info.networkId, sizeof(info.networkId), '\0', sizeof(info.networkId));
728 bool ret = LnnIsLSANode(&info);
729 EXPECT_TRUE(ret == false);
730
731 int32_t nodeNum = 0;
732 int32_t res = LnnGetAllOnlineNodeNum(nullptr);
733 EXPECT_TRUE(res == SOFTBUS_INVALID_PARAM);
734 res = LnnGetAllOnlineNodeNum(&nodeNum);
735 EXPECT_TRUE(res == SOFTBUS_OK);
736 }
737
738 HWTEST_F(LNNDisctributedLedgerTest, LNN_GETNETWORKID_BYUDIDHASH_Test_001, TestSize.Level1)
739 {
740 uint8_t udidHash[UDID_HASH_LEN] = {0};
741 char buf = '0';
742 uint32_t len = 0;
743 int32_t ret = LnnGetNetworkIdByUdidHash(nullptr, len, nullptr, len);
744 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
745 ret = LnnGetNetworkIdByUdidHash(udidHash, UDID_HASH_LEN, &buf, len);
746 EXPECT_TRUE(ret != SOFTBUS_OK);
747 }
748
749 HWTEST_F(LNNDisctributedLedgerTest, LNN_GETDL_ONLINETIMESTAMP_Test_001, TestSize.Level1)
750 {
751 uint64_t timestamp = 0;
752 int32_t ret = LnnGetDLOnlineTimestamp(nullptr, ×tamp);
753 EXPECT_TRUE(ret != SOFTBUS_OK);
754 }
755
756 HWTEST_F(LNNDisctributedLedgerTest, LNN_SETDL_BATTERYINFO_Test_001, TestSize.Level1)
757 {
758 const char *networkId = "softBus";
759 BatteryInfo info;
760 int32_t ret = LnnSetDLBatteryInfo(nullptr, &info);
761 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
762 ret = LnnSetDLBatteryInfo(networkId, &info);
763 EXPECT_TRUE(ret != SOFTBUS_OK);
764 }
765
766 HWTEST_F(LNNDisctributedLedgerTest, LNN_SETDL_BSSTRANSINFO_Test_001, TestSize.Level1)
767 {
768 const char *networkId = "softBus";
769 BssTransInfo info;
770 int32_t ret = LnnSetDLBssTransInfo(nullptr, &info);
771 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
772 ret = LnnSetDLBssTransInfo(networkId, &info);
773 EXPECT_TRUE(ret != SOFTBUS_OK);
774 }
775
776 HWTEST_F(LNNDisctributedLedgerTest, LNN_SETDL_PROXYPORT_Test_001, TestSize.Level1)
777 {
778 IdCategory type = CATEGORY_NETWORK_ID;
779 int32_t proxyPort = 0;
780 int32_t ret = LnnSetDLProxyPort(nullptr, type, proxyPort);
781 EXPECT_TRUE(ret != SOFTBUS_OK);
782 }
783
784 HWTEST_F(LNNDisctributedLedgerTest, LNN_SETDL_SESSIONPORT_Test_001, TestSize.Level1)
785 {
786 IdCategory type = CATEGORY_NETWORK_ID;
787 int32_t sessionPort = 0;
788 int32_t ret = LnnSetDLSessionPort(nullptr, type, sessionPort);
789 EXPECT_TRUE(ret != SOFTBUS_OK);
790 }
791
792 HWTEST_F(LNNDisctributedLedgerTest, LNN_SETDL_AUTHPORT_Test_001, TestSize.Level1)
793 {
794 const char *id = "softBus";
795 IdCategory type = CATEGORY_NETWORK_ID;
796 int32_t authPort = 0;
797 int32_t ret = LnnSetDLAuthPort(nullptr, type, authPort);
798 EXPECT_TRUE(ret != SOFTBUS_OK);
799 ret = LnnSetDLAuthPort(id, type, authPort);
800 EXPECT_TRUE(ret != SOFTBUS_OK);
801 }
802
803 HWTEST_F(LNNDisctributedLedgerTest, SOFTBUS_DUMPBUSCENTER_Test_001, TestSize.Level1)
804 {
805 int32_t fd = 0;
806 int32_t ret = SoftBusDumpBusCenterRemoteDeviceInfo(fd);
807 EXPECT_TRUE(ret == SOFTBUS_OK);
808 }
809
810 HWTEST_F(LNNDisctributedLedgerTest, LNN_GETREMOTE_BOOLINFO_Test_001, TestSize.Level1)
811 {
812 const char *networkId = "softBus";
813 InfoKey key = BOOL_KEY_END;
814 bool info = false;
815 int32_t ret = LnnGetRemoteBoolInfo(nullptr, key, nullptr);
816 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
817 ret = LnnGetRemoteBoolInfo(networkId, key, nullptr);
818 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
819 ret = LnnGetRemoteBoolInfo(networkId, key, &info);
820 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
821 key = BOOL_KEY_BEGIN;
822 ret = LnnGetRemoteBoolInfo(networkId, key, &info);
823 EXPECT_TRUE(ret != SOFTBUS_OK);
824 }
825
826 HWTEST_F(LNNDisctributedLedgerTest, LNN_GETREMOTE_NUMU64INFO_Test_001, TestSize.Level1)
827 {
828 const char *networkId = "softBus";
829 InfoKey key = BOOL_KEY_END;
830 uint64_t info = 0;
831 int32_t ret = LnnGetRemoteNumU64Info(nullptr, key, nullptr);
832 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
833 ret = LnnGetRemoteNumU64Info(networkId, key, nullptr);
834 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
835 ret = LnnGetRemoteNumU64Info(networkId, key, &info);
836 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
837 key = BOOL_KEY_BEGIN;
838 ret = LnnGetRemoteNumU64Info(networkId, key, &info);
839 EXPECT_TRUE(ret != SOFTBUS_OK);
840 }
841
842 HWTEST_F(LNNDisctributedLedgerTest, LNN_GETREMOTE_NODEINFO_Test_001, TestSize.Level1)
843 {
844 const char *networkId = "softBus";
845 IdCategory type = CATEGORY_NETWORK_ID;
846 NodeInfo info;
847 int32_t ret = LnnGetRemoteNodeInfoById(networkId, type, &info);
848 EXPECT_TRUE(ret != SOFTBUS_OK);
849 }
850
851 HWTEST_F(LNNDisctributedLedgerTest, LNN_REFRESH_DEVICEONLINE_ANDINFO_Test_001, TestSize.Level1)
852 {
853 DeviceInfo device;
854 InnerDeviceInfoAddtions additions;
855 (void)LnnRefreshDeviceOnlineStateAndDevIdInfo(nullptr, &device, &additions);
856
857 (void)memset_s(device.devId, sizeof(device.devId), '\0', sizeof(device.devId));
858 additions.medium = COAP;
859 device.isOnline = true;
860 (void)LnnRefreshDeviceOnlineStateAndDevIdInfo(nullptr, &device, &additions);
861 EXPECT_TRUE(device.isOnline == false);
862
863 additions.medium = BLE;
864 device.isOnline = true;
865 (void)LnnRefreshDeviceOnlineStateAndDevIdInfo(nullptr, &device, &additions);
866 EXPECT_TRUE(device.isOnline == false);
867 }
868
869 HWTEST_F(LNNDisctributedLedgerTest, DLGET_FEATURE_CAP_Test_001, TestSize.Level1)
870 {
871 const char *networkId = "softBus";
872 uint32_t len = 0;
873 int32_t ret = DlGetFeatureCap(networkId, true, nullptr, len);
874 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
875 len = LNN_COMMON_LEN_64;
876 ret = DlGetFeatureCap(networkId, true, nullptr, len);
877 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
878 }
879
880 /*
881 * @tc.name: LNN_SET_DLWIFIDIRECT_ADDR_Test_001
882 * @tc.desc: lnn get lnn relation test
883 * @tc.type: FUNC
884 * @tc.require:
885 */
886 HWTEST_F(LNNDisctributedLedgerTest, LNN_SET_DLWIFIDIRECT_ADDR_Test_001, TestSize.Level1)
887 {
888 bool ret = LnnSetDLWifiDirectAddr(NODE1_NETWORK_ID, nullptr);
889 EXPECT_TRUE(ret == false);
890 char wifiDirectAddr1[MAC_LEN] = "11223344556677889";
891 ret = LnnSetDLWifiDirectAddr(nullptr, wifiDirectAddr1);
892 EXPECT_TRUE(ret == false);
893 ret = LnnSetDLWifiDirectAddr(NODE1_NETWORK_ID, wifiDirectAddr1);
894 EXPECT_TRUE(ret == true);
895 ret = LnnSetDLWifiDirectAddr(NODE2_NETWORK_ID, wifiDirectAddr1);
896 EXPECT_TRUE(ret == false);
897
898 char wifiDirectAddr2[MAC_LEN] = "11223344";
899 ret = LnnSetDLWifiDirectAddr(nullptr, wifiDirectAddr2);
900 EXPECT_TRUE(ret == false);
901 ret = LnnSetDLWifiDirectAddr(NODE1_NETWORK_ID, wifiDirectAddr2);
902 EXPECT_TRUE(ret == true);
903 ret = LnnSetDLWifiDirectAddr(NODE2_NETWORK_ID, wifiDirectAddr2);
904 EXPECT_TRUE(ret == false);
905 }
906
907 HWTEST_F(LNNDisctributedLedgerTest, DLGET_STATIC_CAP_Test_001, TestSize.Level1)
908 {
909 uint32_t len = 0;
910 int32_t ret = DlGetStaticCap(nullptr, true, nullptr, len);
911 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
912 len = STATIC_CAP_LEN + 1;
913 ret = DlGetStaticCap(nullptr, true, nullptr, STATIC_CAP_LEN + 1);
914 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
915 const char *networkId = "softbus";
916 ret = DlGetStaticCap(networkId, true, nullptr, STATIC_CAP_LEN + 1);
917 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
918 }
919
920 HWTEST_F(LNNDisctributedLedgerTest, DLGET_STATIC_CAP_LEN_Test_001, TestSize.Level1)
921 {
922 uint32_t len = 0;
923 int32_t ret = DlGetStaticCapLen(nullptr, true, nullptr, len);
924 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
925 len = STATIC_CAP_LEN + 1;
926 ret = DlGetStaticCapLen(nullptr, true, nullptr, STATIC_CAP_LEN + 1);
927 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
928 const char *networkId = "softbus";
929 ret = DlGetStaticCapLen(networkId, true, nullptr, STATIC_CAP_LEN + 1);
930 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
931 }
932
933 HWTEST_F(LNNDisctributedLedgerTest, DLGET_REMOTE_PTK_Test_001, TestSize.Level1)
934 {
935 uint32_t len = 0;
936 int32_t ret = DlGetRemotePtk(nullptr, true, nullptr, len);
937 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
938 len = STATIC_CAP_LEN + 1;
939 ret = DlGetRemotePtk(nullptr, true, nullptr, STATIC_CAP_LEN + 1);
940 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
941 const char *networkId = "softbus";
942 ret = DlGetRemotePtk(networkId, true, nullptr, STATIC_CAP_LEN + 1);
943 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
944 }
945
946 /*
947 * @tc.name: LnnSetDLUnifiedDeviceName_Test_001
948 * @tc.desc: LnnSetDLUnifiedDeviceName
949 * @tc.type: FUNC
950 * @tc.require:
951 */
952 HWTEST_F(LNNDisctributedLedgerTest, Lnn_Set_DLUnifiedDeviceName_Test_001, TestSize.Level1)
953 {
954 char *udid = nullptr;
955 char *name = nullptr;
956 int32_t ret = LnnSetDLUnifiedDeviceName(udid, name);
957 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
958 const char *devUdid = "123456789";
959 const char *devName = "devicename";
960 ret = LnnSetDLUnifiedDeviceName(devUdid, devName);
961 EXPECT_NE(ret, SOFTBUS_OK);
962 }
963
964 /*
965 * @tc.name: LnnSetDLUnifiedDefaultDeviceName_Test_001
966 * @tc.desc: LnnSetDLUnifiedDefaultDeviceName
967 * @tc.type: FUNC
968 * @tc.require:
969 */
970 HWTEST_F(LNNDisctributedLedgerTest, Lnn_Set_DLUnifiedDefaultDeviceName_Test_001, TestSize.Level1)
971 {
972 char *udid = nullptr;
973 char *name = nullptr;
974 int32_t ret = LnnSetDLUnifiedDefaultDeviceName(udid, name);
975 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
976 const char *devUdid = "111111111";
977 const char *devName = "devdefaultdevicename";
978 ret = LnnSetDLUnifiedDefaultDeviceName(devUdid, devName);
979 EXPECT_NE(ret, SOFTBUS_OK);
980 }
981
982 /*
983 * @tc.name: LnnSetDLDeviceNickNameByUdid_Test_001
984 * @tc.desc: LnnSetDLDeviceNickNameByUdid
985 * @tc.type: FUNC
986 * @tc.require:
987 */
988 HWTEST_F(LNNDisctributedLedgerTest, Lnn_Set_DLDeviceNickNameByUdid_Test_001, TestSize.Level1)
989 {
990 char *udid = nullptr;
991 char *name = nullptr;
992 int32_t ret = LnnSetDLDeviceNickNameByUdid(udid, name);
993 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
994 const char *devUdid = "2222222222";
995 const char *devName = "deviceNickname";
996 ret = LnnSetDLDeviceNickNameByUdid(devUdid, devName);
997 EXPECT_NE(ret, SOFTBUS_OK);
998 }
999
1000 /*
1001 * @tc.name: LnnSetDLDeviceStateVersion_Test_001
1002 * @tc.desc: LnnSetDLDeviceStateVersion
1003 * @tc.type: FUNC
1004 * @tc.require:
1005 */
1006 HWTEST_F(LNNDisctributedLedgerTest, Lnn_Set_DLDeviceStateVersion_Test_001, TestSize.Level1)
1007 {
1008 char *udid = nullptr;
1009 int32_t stateVersion = 0;
1010 int32_t ret = LnnSetDLDeviceStateVersion(udid, stateVersion);
1011 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1012 const char *devUdid = "3333333333";
1013 ret = LnnSetDLDeviceStateVersion(devUdid, stateVersion);
1014 EXPECT_NE(ret, SOFTBUS_OK);
1015 }
1016
1017 /*
1018 * @tc.name: LnnSetDLDeviceBroadcastCipherKey_Test_001
1019 * @tc.desc: LnnSetDLDeviceBroadcastCipherKey
1020 * @tc.type: FUNC
1021 * @tc.require:
1022 */
1023 HWTEST_F(LNNDisctributedLedgerTest, Lnn_Set_DLDeviceBroadcastCipherKey_Test_001, TestSize.Level1)
1024 {
1025 char *udid = nullptr;
1026 const char *cipherKey = "qqqqqqqqqqqq";
1027 int32_t ret = LnnSetDLDeviceBroadcastCipherKey(udid, cipherKey);
1028 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1029 const char *devUdid = "123456789";
1030 ret = LnnSetDLDeviceBroadcastCipherKey(devUdid, cipherKey);
1031 EXPECT_NE(ret, SOFTBUS_OK);
1032 }
1033
1034 /*
1035 * @tc.name: LnnSetDLDeviceBroadcastCipherIv_Test_001
1036 * @tc.desc: LnnSetDLDeviceBroadcastCipherIv
1037 * @tc.type: FUNC
1038 * @tc.require:
1039 */
1040 HWTEST_F(LNNDisctributedLedgerTest, Lnn_Set_DLDeviceBroadcastCipherIv_Test_001, TestSize.Level1)
1041 {
1042 char *udid = nullptr;
1043 const char *cipherIv = "qqqqqqqqqqqq";
1044 int32_t ret = LnnSetDLDeviceBroadcastCipherIv(udid, cipherIv);
1045 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1046 const char *devUdid = "123456789";
1047 ret = LnnSetDLDeviceBroadcastCipherIv(devUdid, cipherIv);
1048 EXPECT_NE(ret, SOFTBUS_OK);
1049 }
1050
1051 /*
1052 * @tc.name: LnnUpdateDistributedNodeInfo_Test_001
1053 * @tc.desc: LnnUpdateDistributedNodeInfo
1054 * @tc.type: FUNC
1055 * @tc.require:
1056 */
1057 HWTEST_F(LNNDisctributedLedgerTest, Lnn_UpdateDistributedNodeInfo_Test_001, TestSize.Level1)
1058 {
1059 NodeInfo newInfo;
1060 memset_s(&newInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
1061 const char *udid = nullptr;
1062 newInfo.accountId = 18390933952;
1063 int32_t ret = LnnUpdateDistributedNodeInfo(&newInfo, udid);
1064 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1065 const char *devUdid = "123456789";
1066 ret = LnnUpdateDistributedNodeInfo(&newInfo, devUdid);
1067 EXPECT_EQ(ret, SOFTBUS_OK);
1068 }
1069 } // namespace OHOS
1070