1 /*
2 * Copyright (c) 2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17 #include <securec.h>
18
19 #include "bus_center_manager.h"
20 #include "lnn_connection_addr_utils.h"
21 #include "lnn_distributed_net_ledger_manager_mock.h"
22 #include "lnn_log.h"
23 #include "softbus_adapter_mem.h"
24 #include "g_enhance_lnn_func.h"
25 #include "g_reg_lnn_func.h"
26 #include "softbus_init_common.h"
27
28 namespace OHOS {
29 using namespace testing::ext;
30 using namespace testing;
31
32 constexpr char NODE_NETWORK_ID[] = "123456ABCDEF";
33 constexpr uint64_t DEFAULT_VALUE = 10;
34 constexpr int64_t DEVICE_NAME_DEFAULT_LEN = 128;
35 constexpr int64_t LFINDER_UDID_LEN = 32;
36 constexpr char NODE1_UDID[] = "123456ABCDEF";
37 constexpr char NODE1_NETWORK_ID[] = "235689BNHFCF";
38 constexpr char NODE1_UUID[] = "235689BNHFCC";
39 constexpr char NODE1_BT_MAC[] = "56789TTU";
40 constexpr int64_t AUTH_SEQ = 1;
41 constexpr uint64_t TIME_STAMP = 5000;
42 constexpr uint32_t DISCOVERY_TYPE = 62;
43
44 class LNNDistributedNetLedgerManagerTest : public testing::Test {
45 public:
46 static void SetUpTestCase();
47 static void TearDownTestCase();
48 void SetUp();
49 void TearDown();
50 };
51
LnnRetrieveDeviceInfoByUdidStub(const char * udid,NodeInfo * deviceInfo)52 int32_t LnnRetrieveDeviceInfoByUdidStub(const char *udid, NodeInfo *deviceInfo)
53 {
54 (void)udid;
55 (void)deviceInfo;
56 static bool gRetry = false;
57 if (!gRetry) {
58 gRetry = true;
59 return SOFTBUS_MEM_ERR;
60 }
61 return SOFTBUS_OK;
62 }
63
LnnSaveRemoteDeviceInfoStub(const NodeInfo * deviceInfo)64 int32_t LnnSaveRemoteDeviceInfoStub(const NodeInfo *deviceInfo)
65 {
66 (void)deviceInfo;
67 return SOFTBUS_OK;
68 }
69
SetUpTestCase()70 void LNNDistributedNetLedgerManagerTest::SetUpTestCase()
71 {
72 }
73
TearDownTestCase()74 void LNNDistributedNetLedgerManagerTest::TearDownTestCase()
75 {
76 }
77
SetUp()78 void LNNDistributedNetLedgerManagerTest::SetUp()
79 {
80 LNN_LOGI(LNN_TEST, "LNNDistributedNetLedgerManagerTest start");
81 int32_t ret = LnnInitDistributedLedger();
82 EXPECT_EQ(ret, SOFTBUS_OK);
83 NodeInfo info;
84 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
85 info.discoveryType = DISCOVERY_TYPE;
86 (void)strncpy_s(info.uuid, UUID_BUF_LEN, NODE1_UUID, strlen(NODE1_UUID));
87 (void)strncpy_s(info.deviceInfo.deviceUdid, UDID_BUF_LEN, NODE1_UDID, strlen(NODE1_UDID));
88 (void)strncpy_s(info.networkId, NETWORK_ID_BUF_LEN, NODE1_NETWORK_ID, strlen(NODE1_NETWORK_ID));
89 (void)strncpy_s(info.connectInfo.macAddr, MAC_LEN, NODE1_BT_MAC, strlen(NODE1_BT_MAC));
90 info.authSeq[0] = AUTH_SEQ;
91 info.heartbeatTimestamp = TIME_STAMP;
92 info.deviceInfo.osType = HO_OS_TYPE;
93
94 NiceMock<LnnDistributedNetLedgerManagerInterfaceMock> mock;
95 EXPECT_CALL(mock, LnnRetrieveDeviceInfo).WillRepeatedly(Return(SOFTBUS_OK));
96 EXPECT_EQ(REPORT_ONLINE, LnnAddOnlineNode(&info));
97 }
98
TearDown()99 void LNNDistributedNetLedgerManagerTest::TearDown()
100 {
101 LNN_LOGI(LNN_TEST, "LNNDistributedNetLedgerManagerTest end");
102 LnnDeinitDistributedLedger();
103 }
104
105 /*
106 * @tc.name: LNN_SET_DL_WIFI_DIRECT_ADDR_TEST_001
107 * @tc.desc: LnnSetDLWifiDirectAddr test
108 * @tc.type: FUNC
109 * @tc.require:
110 */
111 HWTEST_F(LNNDistributedNetLedgerManagerTest, LNN_SET_DL_WIFI_DIRECT_ADDR_TEST_001, TestSize.Level1)
112 {
113 NodeInfo *nodeInfo = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
114 ASSERT_NE(nodeInfo, nullptr);
115 LnnDistributedNetLedgerManagerInterfaceMock mock;
116 EXPECT_CALL(mock, LnnGetNodeInfoById).WillRepeatedly(Return(nodeInfo));
117
118 char wifiDirectAddr[MAC_LEN] = "11223344";
119 bool ret = LnnSetDLWifiDirectAddr(NODE_NETWORK_ID, wifiDirectAddr);
120 EXPECT_TRUE(ret);
121 ret = LnnSetDLWifiDirectAddr(NODE_NETWORK_ID, wifiDirectAddr);
122 EXPECT_TRUE(ret);
123 SoftBusFree(nodeInfo);
124 }
125
126 /*
127 * @tc.name: LNN_SET_DL_P2P_IP_TEST_001
128 * @tc.desc: LnnSetDLP2pIp test
129 * @tc.type: FUNC
130 * @tc.require:
131 */
132 HWTEST_F(LNNDistributedNetLedgerManagerTest, LNN_SET_DL_P2P_IP_TEST_001, TestSize.Level1)
133 {
134 NodeInfo *nodeInfo = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
135 ASSERT_NE(nodeInfo, nullptr);
136 LnnDistributedNetLedgerManagerInterfaceMock mock;
137 EXPECT_CALL(mock, LnnGetNodeInfoById).WillOnce(Return(nullptr)).WillRepeatedly(Return(nodeInfo));
138
139 const char *peerUuid = "testUuid";
140 const char *p2pIp = "10.50.140.1";
141 int32_t ret = LnnSetDLP2pIp(nullptr, CATEGORY_UUID, p2pIp);
142 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
143 ret = LnnSetDLP2pIp(peerUuid, CATEGORY_UUID, nullptr);
144 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
145 ret = LnnSetDLP2pIp(peerUuid, CATEGORY_UUID, p2pIp);
146 EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
147 ret = LnnSetDLP2pIp(peerUuid, CATEGORY_UUID, p2pIp);
148 EXPECT_EQ(ret, SOFTBUS_OK);
149 SoftBusFree(nodeInfo);
150 }
151
152 /*
153 * @tc.name: LNN_SET_DL_AUTH_PORT_TEST_001
154 * @tc.desc: LnnSetDLAuthPort test
155 * @tc.type: FUNC
156 * @tc.require:
157 */
158 HWTEST_F(LNNDistributedNetLedgerManagerTest, LNN_SET_DL_AUTH_PORT_TEST_001, TestSize.Level1)
159 {
160 NodeInfo *nodeInfo = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
161 ASSERT_NE(nodeInfo, nullptr);
162 LnnDistributedNetLedgerManagerInterfaceMock mock;
163 EXPECT_CALL(mock, LnnGetNodeInfoById).WillOnce(Return(nullptr)).WillRepeatedly(Return(nodeInfo));
164
165 int32_t authPort = 10;
166 int32_t ret = LnnSetDLAuthPort(NODE_NETWORK_ID, CATEGORY_NETWORK_ID, authPort);
167 EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
168 ret = LnnSetDLAuthPort(NODE_NETWORK_ID, CATEGORY_NETWORK_ID, authPort);
169 EXPECT_EQ(ret, SOFTBUS_OK);
170 SoftBusFree(nodeInfo);
171 }
172
173 /*
174 * @tc.name: LNN_SET_DL_SESSION_PORT_TEST_001
175 * @tc.desc: LnnSetDLSessionPort test
176 * @tc.type: FUNC
177 * @tc.require:
178 */
179 HWTEST_F(LNNDistributedNetLedgerManagerTest, LNN_SET_DL_SESSION_PORT_TEST_001, TestSize.Level1)
180 {
181 NodeInfo *nodeInfo = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
182 ASSERT_NE(nodeInfo, nullptr);
183 LnnDistributedNetLedgerManagerInterfaceMock mock;
184 EXPECT_CALL(mock, LnnGetNodeInfoById).WillOnce(Return(nullptr)).WillRepeatedly(Return(nodeInfo));
185
186 int32_t sessionPort = 10;
187 int32_t ret = LnnSetDLSessionPort(NODE_NETWORK_ID, CATEGORY_NETWORK_ID, sessionPort);
188 EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
189 ret = LnnSetDLSessionPort(NODE_NETWORK_ID, CATEGORY_NETWORK_ID, sessionPort);
190 EXPECT_EQ(ret, SOFTBUS_OK);
191 SoftBusFree(nodeInfo);
192 }
193
194 /*
195 * @tc.name: LNN_SET_DL_PROXY_PORT_TEST_001
196 * @tc.desc: LnnSetDLProxyPort test
197 * @tc.type: FUNC
198 * @tc.require:
199 */
200 HWTEST_F(LNNDistributedNetLedgerManagerTest, LNN_SET_DL_PROXY_PORT_TEST_001, TestSize.Level1)
201 {
202 NodeInfo *nodeInfo = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
203 ASSERT_NE(nodeInfo, nullptr);
204 LnnDistributedNetLedgerManagerInterfaceMock mock;
205 EXPECT_CALL(mock, LnnGetNodeInfoById).WillOnce(Return(nullptr)).WillRepeatedly(Return(nodeInfo));
206
207 int32_t proxyPort = 10;
208 int32_t ret = LnnSetDLProxyPort(NODE_NETWORK_ID, CATEGORY_NETWORK_ID, proxyPort);
209 EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
210 ret = LnnSetDLProxyPort(NODE_NETWORK_ID, CATEGORY_NETWORK_ID, proxyPort);
211 EXPECT_EQ(ret, SOFTBUS_OK);
212 SoftBusFree(nodeInfo);
213 }
214
215 /*
216 * @tc.name: LNN_SET_DL_NODE_ADDR_TEST_001
217 * @tc.desc: LnnSetDLNodeAddr test
218 * @tc.type: FUNC
219 * @tc.require:
220 */
221 HWTEST_F(LNNDistributedNetLedgerManagerTest, LNN_SET_DL_NODE_ADDR_TEST_001, TestSize.Level1)
222 {
223 NodeInfo *nodeInfo = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
224 ASSERT_NE(nodeInfo, nullptr);
225 LnnDistributedNetLedgerManagerInterfaceMock mock;
226 EXPECT_CALL(mock, LnnGetNodeInfoById).WillOnce(Return(nullptr)).WillRepeatedly(Return(nodeInfo));
227
228 const char *nodeAddress = "address";
229 int32_t ret = LnnSetDLNodeAddr(NODE_NETWORK_ID, CATEGORY_NETWORK_ID, nodeAddress);
230 EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
231 ret = LnnSetDLNodeAddr(NODE_NETWORK_ID, CATEGORY_NETWORK_ID, nodeAddress);
232 EXPECT_EQ(ret, SOFTBUS_OK);
233 SoftBusFree(nodeInfo);
234 }
235
236 /*
237 * @tc.name: LNN_SET_DL_BSS_TRANS_INFO_TEST_001
238 * @tc.desc: LnnSetDLBssTransInfo test
239 * @tc.type: FUNC
240 * @tc.require:
241 */
242 HWTEST_F(LNNDistributedNetLedgerManagerTest, LNN_SET_DL_BSS_TRANS_INFO_TEST_001, TestSize.Level1)
243 {
244 NodeInfo *nodeInfo = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
245 ASSERT_NE(nodeInfo, nullptr);
246 LnnDistributedNetLedgerManagerInterfaceMock mock;
247 EXPECT_CALL(mock, LnnGetNodeInfoById).WillOnce(Return(nullptr)).WillRepeatedly(Return(nodeInfo));
248
249 BssTransInfo info;
250 (void)memset_s(&info, sizeof(BssTransInfo), 0, sizeof(BssTransInfo));
251
252 int32_t ret = LnnSetDLBssTransInfo(nullptr, &info);
253 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
254 ret = LnnSetDLBssTransInfo(NODE_NETWORK_ID, nullptr);
255 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
256 ret = LnnSetDLBssTransInfo(NODE_NETWORK_ID, &info);
257 EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
258 ret = LnnSetDLBssTransInfo(NODE_NETWORK_ID, &info);
259 EXPECT_EQ(ret, SOFTBUS_OK);
260 SoftBusFree(nodeInfo);
261 }
262
263 /*
264 * @tc.name: LNN_SET_DL_BATTERY_INFO_TEST_001
265 * @tc.desc: LnnSetDLBatteryInfo test
266 * @tc.type: FUNC
267 * @tc.require:
268 */
269 HWTEST_F(LNNDistributedNetLedgerManagerTest, LNN_SET_DL_BATTERY_INFO_TEST_001, TestSize.Level1)
270 {
271 NodeInfo *nodeInfo = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
272 ASSERT_NE(nodeInfo, nullptr);
273 LnnDistributedNetLedgerManagerInterfaceMock mock;
274 EXPECT_CALL(mock, LnnGetNodeInfoById).WillOnce(Return(nullptr)).WillRepeatedly(Return(nodeInfo));
275
276 BatteryInfo battery;
277 (void)memset_s(&battery, sizeof(BatteryInfo), 0, sizeof(BatteryInfo));
278
279 int32_t ret = LnnSetDLBatteryInfo(nullptr, &battery);
280 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
281 ret = LnnSetDLBatteryInfo(NODE_NETWORK_ID, nullptr);
282 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
283 ret = LnnSetDLBatteryInfo(NODE_NETWORK_ID, &battery);
284 EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
285 ret = LnnSetDLBatteryInfo(NODE_NETWORK_ID, &battery);
286 EXPECT_EQ(ret, SOFTBUS_OK);
287 SoftBusFree(nodeInfo);
288 }
289
290 /*
291 * @tc.name: LNN_SET_DL_CONN_USER_ID_TEST_001
292 * @tc.desc: LnnSetDLConnUserId test
293 * @tc.type: FUNC
294 * @tc.require:
295 */
296 HWTEST_F(LNNDistributedNetLedgerManagerTest, LNN_SET_DL_CONN_USER_ID_TEST_001, TestSize.Level1)
297 {
298 NodeInfo *nodeInfo = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
299 ASSERT_NE(nodeInfo, nullptr);
300
301 LnnEnhanceFuncList *pfnLnnEnhanceFuncList = LnnEnhanceFuncListGet();
302 pfnLnnEnhanceFuncList->lnnSaveRemoteDeviceInfo = nullptr;
303 LnnDistributedNetLedgerManagerInterfaceMock mock;
304 EXPECT_CALL(mock, LnnGetNodeInfoById).WillOnce(Return(nullptr)).WillRepeatedly(Return(nodeInfo));
305 int32_t userId = 0;
306 int32_t ret = LnnSetDLConnUserId(nullptr, userId);
307 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
308 ret = LnnSetDLConnUserId(NODE_NETWORK_ID, userId);
309 EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
310 ret = LnnSetDLConnUserId(NODE_NETWORK_ID, userId);
311 EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
312 ret = LnnSetDLConnUserId(NODE_NETWORK_ID, userId);
313 EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
314 SoftBusFree(nodeInfo);
315 }
316
317 /*
318 * @tc.name: LNN_SET_DL_CONN_USER_ID_CHECK_SUM_TEST_001
319 * @tc.desc: LnnSetDLConnUserIdCheckSum test
320 * @tc.type: FUNC
321 * @tc.require:
322 */
323 HWTEST_F(LNNDistributedNetLedgerManagerTest, LNN_SET_DL_CONN_USER_ID_CHECK_SUM_TEST_001, TestSize.Level1)
324 {
325 NodeInfo *nodeInfo = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
326 ASSERT_NE(nodeInfo, nullptr);
327
328 LnnEnhanceFuncList *pfnLnnEnhanceFuncList = LnnEnhanceFuncListGet();
329 pfnLnnEnhanceFuncList->lnnSaveRemoteDeviceInfo = nullptr;
330 LnnDistributedNetLedgerManagerInterfaceMock mock;
331 EXPECT_CALL(mock, LnnGetNodeInfoById).WillOnce(Return(nullptr)).WillRepeatedly(Return(nodeInfo));
332 int32_t userIdCheckSum = 0;
333 int32_t ret = LnnSetDLConnUserIdCheckSum(nullptr, userIdCheckSum);
334 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
335 ret = LnnSetDLConnUserIdCheckSum(NODE_NETWORK_ID, userIdCheckSum);
336 EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
337 ret = LnnSetDLConnUserIdCheckSum(NODE_NETWORK_ID, userIdCheckSum);
338 EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
339 ret = LnnSetDLConnUserIdCheckSum(NODE_NETWORK_ID, userIdCheckSum);
340 EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
341 SoftBusFree(nodeInfo);
342 }
343
344 /*
345 * @tc.name: LNN_SET_DL_CONN_CAPABILITY_TEST_001
346 * @tc.desc: LnnSetDLConnCapability test
347 * @tc.type: FUNC
348 * @tc.require:
349 */
350 HWTEST_F(LNNDistributedNetLedgerManagerTest, LNN_SET_DL_CONN_CAPABILITY_TEST_001, TestSize.Level1)
351 {
352 LnnEnhanceFuncList *pfnLnnEnhanceFuncList = LnnEnhanceFuncListGet();
353 pfnLnnEnhanceFuncList->lnnRetrieveDeviceInfoByUdid = LnnRetrieveDeviceInfoByUdidStub;
354 pfnLnnEnhanceFuncList->lnnSaveRemoteDeviceInfo = LnnSaveRemoteDeviceInfoStub;
355 NodeInfo *nodeInfo = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
356 ASSERT_NE(nodeInfo, nullptr);
357 LnnDistributedNetLedgerManagerInterfaceMock mock;
358 EXPECT_CALL(mock, LnnGetNodeInfoById).WillOnce(Return(nullptr)).WillRepeatedly(Return(nodeInfo));
359 uint32_t connCapability = 0;
360 int32_t ret = LnnSetDLConnCapability(NODE_NETWORK_ID, connCapability);
361 EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
362
363 pfnLnnEnhanceFuncList->lnnRetrieveDeviceInfoByUdid = nullptr;
364 pfnLnnEnhanceFuncList->lnnSaveRemoteDeviceInfo = nullptr;
365 ret = LnnSetDLConnCapability(NODE_NETWORK_ID, connCapability);
366 EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
367 ret = LnnSetDLConnCapability(NODE_NETWORK_ID, connCapability);
368 EXPECT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
369 SoftBusFree(nodeInfo);
370 }
371
372 /*
373 * @tc.name: LNN_SET_DL_BLE_DIRECT_TIMESTAMP_TEST_001
374 * @tc.desc: LnnSetDLBleDirectTimestamp test
375 * @tc.type: FUNC
376 * @tc.require:
377 */
378 HWTEST_F(LNNDistributedNetLedgerManagerTest, LNN_SET_DL_BLE_DIRECT_TIMESTAMP_TEST_001, TestSize.Level1)
379 {
380 NodeInfo *nodeInfo = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
381 ASSERT_NE(nodeInfo, nullptr);
382 LnnDistributedNetLedgerManagerInterfaceMock mock;
383 EXPECT_CALL(mock, LnnGetNodeInfoById).WillOnce(Return(nullptr)).WillRepeatedly(Return(nodeInfo));
384
385 uint64_t timestamp = DEFAULT_VALUE;
386 int32_t ret = LnnSetDLBleDirectTimestamp(NODE_NETWORK_ID, timestamp);
387 EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
388 ret = LnnSetDLBleDirectTimestamp(NODE_NETWORK_ID, timestamp);
389 EXPECT_EQ(ret, SOFTBUS_OK);
390 SoftBusFree(nodeInfo);
391 }
392
393 /*
394 * @tc.name: LNN_GET_DL_AUTH_CAPACITY_TEST_001
395 * @tc.desc: LnnGetDLAuthCapacity test
396 * @tc.type: FUNC
397 * @tc.require:
398 */
399 HWTEST_F(LNNDistributedNetLedgerManagerTest, LNN_GET_DL_AUTH_CAPACITY_TEST_001, TestSize.Level1)
400 {
401 NodeInfo *nodeInfo = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
402 ASSERT_NE(nodeInfo, nullptr);
403 LnnDistributedNetLedgerManagerInterfaceMock mock;
404 EXPECT_CALL(mock, LnnGetNodeInfoById).WillOnce(Return(nullptr)).WillRepeatedly(Return(nodeInfo));
405
406 uint32_t authCapacity = 0;
407 int32_t ret = LnnGetDLAuthCapacity(NODE_NETWORK_ID, &authCapacity);
408 EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
409 ret = LnnGetDLAuthCapacity(NODE_NETWORK_ID, &authCapacity);
410 EXPECT_EQ(ret, SOFTBUS_OK);
411 SoftBusFree(nodeInfo);
412 }
413
414 /*
415 * @tc.name: LNN_GET_DL_UPDATE_TIMESTAMP_TEST_001
416 * @tc.desc: LnnGetDLUpdateTimestamp test
417 * @tc.type: FUNC
418 * @tc.require:
419 */
420 HWTEST_F(LNNDistributedNetLedgerManagerTest, LNN_GET_DL_UPDATE_TIMESTAMP_TEST_001, TestSize.Level1)
421 {
422 NodeInfo *nodeInfo = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
423 ASSERT_NE(nodeInfo, nullptr);
424
425 LnnDistributedNetLedgerManagerInterfaceMock mock;
426 EXPECT_CALL(mock, LnnGetNodeInfoById).WillRepeatedly(Return(nodeInfo));
427 uint64_t timestamp = DEFAULT_VALUE;
428 int32_t ret = LnnGetDLUpdateTimestamp(nullptr, ×tamp);
429 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
430 ret = LnnGetDLUpdateTimestamp(NODE_NETWORK_ID, nullptr);
431 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
432 ret = LnnGetDLUpdateTimestamp(NODE_NETWORK_ID, ×tamp);
433 EXPECT_EQ(ret, SOFTBUS_OK);
434 ret = LnnGetDLUpdateTimestamp(NODE_NETWORK_ID, ×tamp);
435 EXPECT_EQ(ret, SOFTBUS_OK);
436 SoftBusFree(nodeInfo);
437 }
438
439 /*
440 * @tc.name: LNN_GET_DL_BLE_DIRECT_TIMESTAMP_TEST_001
441 * @tc.desc: LnnGetDLBleDirectTimestamp test
442 * @tc.type: FUNC
443 * @tc.require:
444 */
445 HWTEST_F(LNNDistributedNetLedgerManagerTest, LNN_GET_DL_BLE_DIRECT_TIMESTAMP_TEST_001, TestSize.Level1)
446 {
447 NodeInfo *nodeInfo = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
448 ASSERT_NE(nodeInfo, nullptr);
449 LnnDistributedNetLedgerManagerInterfaceMock mock;
450 EXPECT_CALL(mock, LnnGetNodeInfoById).WillOnce(Return(nullptr)).WillRepeatedly(Return(nodeInfo));
451
452 uint64_t timestamp = DEFAULT_VALUE;
453 int32_t ret = LnnGetDLBleDirectTimestamp(nullptr, ×tamp);
454 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
455 ret = LnnGetDLBleDirectTimestamp(NODE_NETWORK_ID, nullptr);
456 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
457 ret = LnnGetDLBleDirectTimestamp(NODE_NETWORK_ID, ×tamp);
458 EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
459 ret = LnnGetDLBleDirectTimestamp(NODE_NETWORK_ID, ×tamp);
460 EXPECT_EQ(ret, SOFTBUS_OK);
461 SoftBusFree(nodeInfo);
462 }
463
464 /*
465 * @tc.name: LNN_SET_DL_HEARTBEAT_TIMESTAMP_TEST_001
466 * @tc.desc: LnnSetDLHeartbeatTimestamp test
467 * @tc.type: FUNC
468 * @tc.require:
469 */
470 HWTEST_F(LNNDistributedNetLedgerManagerTest, LNN_SET_DL_HEARTBEAT_TIMESTAMP_TEST_001, TestSize.Level1)
471 {
472 NodeInfo *nodeInfo = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
473 ASSERT_NE(nodeInfo, nullptr);
474 LnnDistributedNetLedgerManagerInterfaceMock mock;
475 EXPECT_CALL(mock, LnnGetNodeInfoById).WillOnce(Return(nullptr)).WillRepeatedly(Return(nodeInfo));
476
477 uint64_t timestamp = DEFAULT_VALUE;
478 int32_t ret = LnnSetDLHeartbeatTimestamp(NODE_NETWORK_ID, timestamp);
479 EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
480 ret = LnnSetDLHeartbeatTimestamp(NODE_NETWORK_ID, timestamp);
481 EXPECT_EQ(ret, SOFTBUS_OK);
482 SoftBusFree(nodeInfo);
483 }
484
485 /*
486 * @tc.name: LNN_GET_DL_HEARTBEAT_TIMESTAMP_TEST_001
487 * @tc.desc: LnnGetDLHeartbeatTimestamp test
488 * @tc.type: FUNC
489 * @tc.require:
490 */
491 HWTEST_F(LNNDistributedNetLedgerManagerTest, LNN_GET_DL_HEARTBEAT_TIMESTAMP_TEST_001, TestSize.Level1)
492 {
493 NodeInfo *nodeInfo = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
494 ASSERT_NE(nodeInfo, nullptr);
495 LnnDistributedNetLedgerManagerInterfaceMock mock;
496 EXPECT_CALL(mock, LnnGetNodeInfoById).WillOnce(Return(nullptr)).WillRepeatedly(Return(nodeInfo));
497
498 uint64_t timestamp = DEFAULT_VALUE;
499 int32_t ret = LnnGetDLHeartbeatTimestamp(NODE_NETWORK_ID, ×tamp);
500 EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
501 ret = LnnGetDLHeartbeatTimestamp(NODE_NETWORK_ID, ×tamp);
502 EXPECT_EQ(ret, SOFTBUS_OK);
503 SoftBusFree(nodeInfo);
504 }
505
506 /*
507 * @tc.name: LNN_GET_DL_ONLINE_TIMESTAMP_TEST_001
508 * @tc.desc: LnnGetDLOnlineTimestamp test
509 * @tc.type: FUNC
510 * @tc.require:
511 */
512 HWTEST_F(LNNDistributedNetLedgerManagerTest, LNN_GET_DL_ONLINE_TIMESTAMP_TEST_001, TestSize.Level1)
513 {
514 NodeInfo *nodeInfo = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
515 ASSERT_NE(nodeInfo, nullptr);
516 LnnDistributedNetLedgerManagerInterfaceMock mock;
517 EXPECT_CALL(mock, LnnGetNodeInfoById).WillOnce(Return(nullptr)).WillRepeatedly(Return(nodeInfo));
518
519 uint64_t timestamp = DEFAULT_VALUE;
520 int32_t ret = LnnGetDLOnlineTimestamp(NODE_NETWORK_ID, ×tamp);
521 EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
522 ret = LnnGetDLOnlineTimestamp(NODE_NETWORK_ID, ×tamp);
523 EXPECT_EQ(ret, SOFTBUS_OK);
524 SoftBusFree(nodeInfo);
525 }
526
527 /*
528 * @tc.name: LNN_GET_CONN_SUB_FEATURE_BY_UDIDHASH_STR_TEST_001
529 * @tc.desc: LnnGetConnSubFeatureByUdidHashStr test
530 * @tc.type: FUNC
531 * @tc.require:
532 */
533 HWTEST_F(LNNDistributedNetLedgerManagerTest, LNN_GET_CONN_SUB_FEATURE_BY_UDIDHASH_STR_TEST_001, TestSize.Level1)
534 {
535 LnnDistributedNetLedgerManagerInterfaceMock mock;
536 EXPECT_CALL(mock, SoftBusGenerateStrHash).WillRepeatedly(Return(SOFTBUS_OK));
537 EXPECT_CALL(mock, ConvertBytesToHexString).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
538 EXPECT_CALL(mock, LnnIsNodeOnline).WillRepeatedly(Return(false));
539
540 const char *udidHashStr = "deviceudid";
541 uint64_t connSubFeature = DEFAULT_VALUE;
542 int32_t ret = LnnGetConnSubFeatureByUdidHashStr(nullptr, &connSubFeature);
543 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
544 ret = LnnGetConnSubFeatureByUdidHashStr(udidHashStr, nullptr);
545 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
546 ret = LnnGetConnSubFeatureByUdidHashStr(udidHashStr, &connSubFeature);
547 EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
548 }
549
550 /*
551 * @tc.name: LNN_GET_REMOTE_BYTE_INFO_TEST_001
552 * @tc.desc: LnnGetRemoteByteInfo test
553 * @tc.type: FUNC
554 * @tc.require:
555 */
556 HWTEST_F(LNNDistributedNetLedgerManagerTest, LNN_GET_REMOTE_BYTE_INFO_TEST_001, TestSize.Level1)
557 {
558 NodeInfo *nodeInfo = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
559 ASSERT_NE(nodeInfo, nullptr);
560 LnnDistributedNetLedgerManagerInterfaceMock mock;
561 EXPECT_CALL(mock, LnnGetNodeInfoById).WillOnce(Return(nullptr)).WillRepeatedly(Return(nodeInfo));
562
563 unsigned char irk[LFINDER_IRK_LEN] = {0};
564 int32_t ret = LnnGetRemoteByteInfo(nullptr, BYTE_KEY_PUB_MAC, irk, LFINDER_IRK_LEN);
565 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
566 ret = LnnGetRemoteByteInfo(NODE_NETWORK_ID, BYTE_KEY_PUB_MAC, nullptr, LFINDER_IRK_LEN);
567 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
568 ret = LnnGetRemoteByteInfo(NODE_NETWORK_ID, BYTE_KEY_PUB_MAC, irk, LFINDER_IRK_LEN);
569 EXPECT_EQ(ret, SOFTBUS_NETWORK_GET_NODE_INFO_ERR);
570 ret = LnnGetRemoteByteInfo(NODE_NETWORK_ID, BYTE_KEY_PUB_MAC, irk, LFINDER_IRK_LEN);
571 EXPECT_EQ(ret, SOFTBUS_OK);
572 SoftBusFree(nodeInfo);
573 }
574
575 /*
576 * @tc.name: LNN_GET_REMOTE_BYTE_INFO_TEST_002
577 * @tc.desc: LnnGetRemoteByteInfo test
578 * @tc.type: FUNC
579 * @tc.require:
580 */
581 HWTEST_F(LNNDistributedNetLedgerManagerTest, LNN_GET_REMOTE_BYTE_INFO_TEST_002, TestSize.Level1)
582 {
583 NodeInfo *nodeInfo = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
584 ASSERT_NE(nodeInfo, nullptr);
585 LnnDistributedNetLedgerManagerInterfaceMock mock;
586 EXPECT_CALL(mock, LnnGetNodeInfoById).WillOnce(Return(nullptr)).WillRepeatedly(Return(nodeInfo));
587
588 unsigned char irk[LFINDER_UDID_LEN] = {0};
589 int32_t ret = LnnGetRemoteByteInfo(nullptr, BYTE_KEY_ACCOUNT_HASH, irk, LFINDER_UDID_LEN);
590 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
591 ret = LnnGetRemoteByteInfo(NODE_NETWORK_ID, BYTE_KEY_ACCOUNT_HASH, nullptr, LFINDER_UDID_LEN);
592 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
593 ret = LnnGetRemoteByteInfo(NODE_NETWORK_ID, BYTE_KEY_ACCOUNT_HASH, irk, LFINDER_UDID_LEN);
594 EXPECT_EQ(ret, SOFTBUS_NETWORK_GET_NODE_INFO_ERR);
595 ret = LnnGetRemoteByteInfo(NODE_NETWORK_ID, BYTE_KEY_ACCOUNT_HASH, irk, LFINDER_UDID_LEN);
596 EXPECT_EQ(ret, SOFTBUS_NETWORK_NODE_OFFLINE);
597 ret = LnnGetRemoteByteInfo(NODE_NETWORK_ID, BYTE_KEY_ACCOUNT_HASH, irk, LFINDER_UDID_LEN);
598 EXPECT_EQ(ret, SOFTBUS_NETWORK_NODE_OFFLINE);
599 SoftBusFree(nodeInfo);
600 }
601
602 /*
603 * @tc.name: LNN_GET_REMOTE_BYTE_INFO_TEST_003
604 * @tc.desc: LnnGetRemoteByteInfo test
605 * @tc.type: FUNC
606 * @tc.require:
607 */
608 HWTEST_F(LNNDistributedNetLedgerManagerTest, LNN_GET_REMOTE_BYTE_INFO_TEST_003, TestSize.Level1)
609 {
610 NodeInfo *nodeInfo = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
611 ASSERT_NE(nodeInfo, nullptr);
612 LnnDistributedNetLedgerManagerInterfaceMock mock;
613 EXPECT_CALL(mock, LnnGetNodeInfoById).WillOnce(Return(nullptr)).WillRepeatedly(Return(nodeInfo));
614
615 unsigned char irk[LFINDER_UDID_HASH_LEN] = {0};
616 int32_t ret = LnnGetRemoteByteInfo(NODE_NETWORK_ID, BYTE_KEY_REMOTE_PTK, irk, LFINDER_UDID_HASH_LEN);
617 EXPECT_EQ(ret, SOFTBUS_NETWORK_GET_NODE_INFO_ERR);
618 ret = LnnGetRemoteByteInfo(NODE_NETWORK_ID, BYTE_KEY_REMOTE_PTK, irk, LFINDER_UDID_HASH_LEN);
619 EXPECT_EQ(ret, SOFTBUS_OK);
620 SoftBusFree(nodeInfo);
621 }
622
623 /*
624 * @tc.name: LNN_GET_REMOTE_BOOL_INFO_IGNORE_ONLINE_TEST_001
625 * @tc.desc: LnnGetRemoteBoolInfoIgnoreOnline test
626 * @tc.type: FUNC
627 * @tc.require:
628 */
629 HWTEST_F(LNNDistributedNetLedgerManagerTest, LNN_GET_REMOTE_BOOL_INFO_IGNORE_ONLINE_TEST_001, TestSize.Level1)
630 {
631 NodeInfo *nodeInfo = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
632 ASSERT_NE(nodeInfo, nullptr);
633 LnnDistributedNetLedgerManagerInterfaceMock mock;
634 EXPECT_CALL(mock, LnnGetNodeInfoById).WillOnce(Return(nullptr)).WillRepeatedly(Return(nodeInfo));
635 EXPECT_CALL(mock, LnnIsNodeOnline).WillRepeatedly(Return(false));
636
637 bool result = false;
638 int32_t ret = LnnGetRemoteBoolInfoIgnoreOnline(nullptr, BOOL_KEY_SCREEN_STATUS, &result);
639 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
640 ret = LnnGetRemoteBoolInfoIgnoreOnline(NODE_NETWORK_ID, BOOL_KEY_SCREEN_STATUS, &result);
641 EXPECT_EQ(ret, SOFTBUS_NETWORK_GET_NODE_INFO_ERR);
642 nodeInfo->heartbeatCapacity = 0;
643 ret = LnnGetRemoteBoolInfoIgnoreOnline(NODE_NETWORK_ID, BOOL_KEY_SCREEN_STATUS, &result);
644 EXPECT_EQ(ret, SOFTBUS_NETWORK_NOT_SUPPORT);
645 nodeInfo->heartbeatCapacity = 63;
646 ret = LnnGetRemoteBoolInfoIgnoreOnline(NODE_NETWORK_ID, BOOL_KEY_SCREEN_STATUS, &result);
647 EXPECT_EQ(ret, SOFTBUS_OK);
648
649 nodeInfo->metaInfo.isMetaNode = false;
650 ret = LnnGetRemoteBoolInfo(NODE_NETWORK_ID, BOOL_KEY_SCREEN_STATUS, &result);
651 EXPECT_EQ(ret, SOFTBUS_NETWORK_NODE_OFFLINE);
652 SoftBusFree(nodeInfo);
653 }
654
655 /*
656 * @tc.name: LNN_GET_REMOTE_BOOL_INFO_IGNORE_ONLINE_TEST_002
657 * @tc.desc: LnnGetRemoteBoolInfoIgnoreOnline test
658 * @tc.type: FUNC
659 * @tc.require:
660 */
661 HWTEST_F(LNNDistributedNetLedgerManagerTest, LNN_GET_REMOTE_BOOL_INFO_IGNORE_ONLINE_TEST_002, TestSize.Level1)
662 {
663 NodeInfo *nodeInfo = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
664 ASSERT_NE(nodeInfo, nullptr);
665 LnnDistributedNetLedgerManagerInterfaceMock mock;
666 EXPECT_CALL(mock, LnnGetNodeInfoById).WillOnce(Return(nullptr)).WillRepeatedly(Return(nodeInfo));
667 EXPECT_CALL(mock, LnnIsNodeOnline).WillRepeatedly(Return(false));
668
669 bool result = false;
670 int32_t ret = LnnGetRemoteBoolInfoIgnoreOnline(nullptr, BOOL_KEY_TLV_NEGOTIATION, &result);
671 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
672 ret = LnnGetRemoteBoolInfoIgnoreOnline(NODE_NETWORK_ID, BOOL_KEY_TLV_NEGOTIATION, &result);
673 EXPECT_EQ(ret, SOFTBUS_NETWORK_GET_NODE_INFO_ERR);
674 ret = LnnGetRemoteBoolInfoIgnoreOnline(NODE_NETWORK_ID, BOOL_KEY_TLV_NEGOTIATION, &result);
675 EXPECT_EQ(ret, SOFTBUS_OK);
676
677 nodeInfo->metaInfo.isMetaNode = false;
678 ret = LnnGetRemoteBoolInfo(NODE_NETWORK_ID, BOOL_KEY_TLV_NEGOTIATION, &result);
679 EXPECT_EQ(ret, SOFTBUS_NETWORK_NODE_OFFLINE);
680 SoftBusFree(nodeInfo);
681 }
682
683 /*
684 * @tc.name: LNN_SET_DL_PTK_TEST_001
685 * @tc.desc: LnnSetDlPtk test
686 * @tc.type: FUNC
687 * @tc.require:
688 */
689 HWTEST_F(LNNDistributedNetLedgerManagerTest, LNN_SET_DL_PTK_TEST_001, TestSize.Level1)
690 {
691 NodeInfo *nodeInfo = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
692 ASSERT_NE(nodeInfo, nullptr);
693 LnnDistributedNetLedgerManagerInterfaceMock mock;
694 EXPECT_CALL(mock, ConvertBytesToHexString).WillRepeatedly(Return(SOFTBUS_OK));
695
696 const char *remotePtk = "testRemotePtk";
697 bool ret = LnnSetDlPtk(nullptr, remotePtk);
698 EXPECT_FALSE(ret);
699 ret = LnnSetDlPtk(NODE_NETWORK_ID, nullptr);
700 EXPECT_FALSE(ret);
701
702 EXPECT_CALL(mock, LnnGetNodeInfoById).WillRepeatedly(Return(nullptr));
703 ret = LnnSetDlPtk(NODE_NETWORK_ID, remotePtk);
704 EXPECT_FALSE(ret);
705
706 EXPECT_CALL(mock, LnnGetNodeInfoById).WillRepeatedly(Return(nodeInfo));
707 EXPECT_CALL(mock, SoftBusGenerateStrHash).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
708 ret = LnnSetDlPtk(NODE_NETWORK_ID, remotePtk);
709 EXPECT_FALSE(ret);
710
711 EXPECT_CALL(mock, SoftBusGenerateStrHash).WillRepeatedly(Return(SOFTBUS_OK));
712 ret = LnnSetDlPtk(NODE_NETWORK_ID, remotePtk);
713 EXPECT_TRUE(ret);
714 SoftBusFree(nodeInfo);
715 }
716
717 /*
718 * @tc.name: LNN_SET_DL_DEVICE_BROADCAST_CIPHERIV_TEST_001
719 * @tc.desc: LnnSetDLDeviceBroadcastCipherIv test
720 * @tc.type: FUNC
721 * @tc.require:
722 */
723 HWTEST_F(LNNDistributedNetLedgerManagerTest, LNN_SET_DL_DEVICE_BROADCAST_CIPHERIV_TEST_001, TestSize.Level1)
724 {
725 NodeInfo *nodeInfo = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
726 ASSERT_NE(nodeInfo, nullptr);
727
728 LnnDistributedNetLedgerManagerInterfaceMock mock;
729 EXPECT_CALL(mock, GetNodeInfoFromMap).WillRepeatedly(Return(nodeInfo));
730 const char *devUdid = "123456ABCDEF";
731 const char *devUdidInvalid = "123456789ABCDEFG";
732 const char *cipherIv = "iviviviviviv";
733 int32_t ret = LnnSetDLDeviceBroadcastCipherIv(devUdidInvalid, cipherIv);
734 EXPECT_EQ(ret, SOFTBUS_OK);
735 ret = LnnSetDLDeviceBroadcastCipherIv(devUdid, cipherIv);
736 EXPECT_EQ(ret, SOFTBUS_OK);
737 SoftBusFree(nodeInfo);
738 }
739
740 /*
741 * @tc.name: LNN_SET_DL_DEVICE_BROADCAST_CIPHER_KEY_TEST_001
742 * @tc.desc: LnnSetDLDeviceBroadcastCipherKey test
743 * @tc.type: FUNC
744 * @tc.require:
745 */
746 HWTEST_F(LNNDistributedNetLedgerManagerTest, LNN_SET_DL_DEVICE_BROADCAST_CIPHER_KEY_TEST_001, TestSize.Level1)
747 {
748 NodeInfo *nodeInfo = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
749 ASSERT_NE(nodeInfo, nullptr);
750
751 LnnDistributedNetLedgerManagerInterfaceMock mock;
752 EXPECT_CALL(mock, GetNodeInfoFromMap).WillRepeatedly(Return(nodeInfo));
753 const char *devUdid = "123456ABCDEF";
754 const char *devUdidInvalid = "123456789ABCDEFG";
755 const char *cipherKey = "keykeykeykey";
756 int32_t ret = LnnSetDLDeviceBroadcastCipherKey(devUdidInvalid, (const void *)cipherKey);
757 EXPECT_EQ(ret, SOFTBUS_OK);
758 ret = LnnSetDLDeviceBroadcastCipherKey(devUdid, (const void *)cipherKey);
759 EXPECT_EQ(ret, SOFTBUS_OK);
760 SoftBusFree(nodeInfo);
761 }
762
763 /*
764 * @tc.name: LNN_SET_DL_DEVICE_STATE_VERSION_TEST_001
765 * @tc.desc: LnnSetDLDeviceStateVersion test
766 * @tc.type: FUNC
767 * @tc.require:
768 */
769 HWTEST_F(LNNDistributedNetLedgerManagerTest, LNN_SET_DL_DEVICE_STATE_VERSION_TEST_001, TestSize.Level1)
770 {
771 NodeInfo *nodeInfo = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
772 ASSERT_NE(nodeInfo, nullptr);
773
774 LnnDistributedNetLedgerManagerInterfaceMock mock;
775 EXPECT_CALL(mock, GetNodeInfoFromMap).WillRepeatedly(Return(nodeInfo));
776 const char *devUdid = "123456ABCDEF";
777 int32_t stateVersion = 0;
778 int32_t ret = LnnSetDLDeviceStateVersion(devUdid, stateVersion);
779 EXPECT_EQ(ret, SOFTBUS_OK);
780 nodeInfo->stateVersion = 0;
781 ret = LnnSetDLDeviceStateVersion(devUdid, stateVersion);
782 EXPECT_EQ(ret, SOFTBUS_OK);
783 nodeInfo->stateVersion = 10;
784 ret = LnnSetDLDeviceStateVersion(devUdid, stateVersion);
785 EXPECT_EQ(ret, SOFTBUS_OK);
786 SoftBusFree(nodeInfo);
787 }
788
789 /*
790 * @tc.name: LNN_SET_DL_DEVICE_NICK_NAME_BY_UDID_TEST_001
791 * @tc.desc: LnnSetDLDeviceNickNameByUdid test
792 * @tc.type: FUNC
793 * @tc.require:
794 */
795 HWTEST_F(LNNDistributedNetLedgerManagerTest, LNN_SET_DL_DEVICE_NICK_NAME_BY_UDID_TEST_001, TestSize.Level1)
796 {
797 NodeInfo *nodeInfo = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
798 ASSERT_NE(nodeInfo, nullptr);
799
800 LnnDistributedNetLedgerManagerInterfaceMock mock;
801 EXPECT_CALL(mock, GetNodeInfoFromMap).WillRepeatedly(Return(nodeInfo));
802 const char *devUdid = "123456ABCDEF";
803 const char *devName = "deviceNickname";
804 int32_t ret = LnnSetDLDeviceNickNameByUdid(nullptr, devName);
805 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
806 ret = LnnSetDLDeviceNickNameByUdid(devUdid, nullptr);
807 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
808 ret = LnnSetDLDeviceNickNameByUdid(devUdid, devName);
809 EXPECT_EQ(ret, SOFTBUS_OK);
810 ret = LnnSetDLDeviceNickNameByUdid(devUdid, devName);
811 EXPECT_EQ(ret, SOFTBUS_OK);
812
813 ASSERT_EQ(strncpy_s(nodeInfo->deviceInfo.nickName, DEVICE_NAME_DEFAULT_LEN, devName, strlen(devName)), EOK);
814 ret = LnnSetDLDeviceNickNameByUdid(devUdid, devName);
815 EXPECT_EQ(ret, SOFTBUS_OK);
816 SoftBusFree(nodeInfo);
817 }
818
819 /*
820 * @tc.name: LNN_SET_DL_UNIFIED_DEFAULT_DEVICE_NAME_TEST_001
821 * @tc.desc: LnnSetDLUnifiedDefaultDeviceName test
822 * @tc.type: FUNC
823 * @tc.require:
824 */
825 HWTEST_F(LNNDistributedNetLedgerManagerTest, LNN_SET_DL_UNIFIED_DEFAULT_DEVICE_NAME_TEST_001, TestSize.Level1)
826 {
827 NodeInfo *nodeInfo = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
828 ASSERT_NE(nodeInfo, nullptr);
829
830 LnnDistributedNetLedgerManagerInterfaceMock mock;
831 EXPECT_CALL(mock, GetNodeInfoFromMap).WillRepeatedly(Return(nodeInfo));
832 const char *devUdid = "123456ABCDEF";
833 const char *devName = "deviceUnifiedDefaultName";
834 int32_t ret = LnnSetDLUnifiedDefaultDeviceName(nullptr, devName);
835 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
836 ret = LnnSetDLUnifiedDefaultDeviceName(devUdid, nullptr);
837 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
838 ret = LnnSetDLUnifiedDefaultDeviceName(devUdid, devName);
839 EXPECT_EQ(ret, SOFTBUS_OK);
840 ret = LnnSetDLUnifiedDefaultDeviceName(devUdid, devName);
841 EXPECT_EQ(ret, SOFTBUS_OK);
842
843 ASSERT_EQ(strncpy_s(nodeInfo->deviceInfo.unifiedDefaultName,
844 DEVICE_NAME_DEFAULT_LEN, devName, strlen(devName)), EOK);
845 ret = LnnSetDLUnifiedDefaultDeviceName(devUdid, devName);
846 EXPECT_EQ(ret, SOFTBUS_OK);
847 SoftBusFree(nodeInfo);
848 }
849
850 /*
851 * @tc.name: LNN_SET_DL_UNIFIED_DEVICE_NAME_TEST_001
852 * @tc.desc: LnnSetDLUnifiedDeviceName test
853 * @tc.type: FUNC
854 * @tc.require:
855 */
856 HWTEST_F(LNNDistributedNetLedgerManagerTest, LNN_SET_DL_UNIFIED_DEVICE_NAME_TEST_001, TestSize.Level1)
857 {
858 NodeInfo *nodeInfo = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
859 ASSERT_NE(nodeInfo, nullptr);
860
861 LnnDistributedNetLedgerManagerInterfaceMock mock;
862 EXPECT_CALL(mock, GetNodeInfoFromMap).WillRepeatedly(Return(nodeInfo));
863 const char *devUdid = "123456ABCDEF";
864 const char *devName = "deviceUnifiedName";
865 int32_t ret = LnnSetDLUnifiedDeviceName(nullptr, devName);
866 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
867 ret = LnnSetDLUnifiedDeviceName(devUdid, nullptr);
868 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
869 ret = LnnSetDLUnifiedDeviceName(devUdid, devName);
870 EXPECT_EQ(ret, SOFTBUS_OK);
871 ret = LnnSetDLUnifiedDeviceName(devUdid, devName);
872 EXPECT_EQ(ret, SOFTBUS_OK);
873
874 ASSERT_EQ(strncpy_s(nodeInfo->deviceInfo.unifiedName, DEVICE_NAME_DEFAULT_LEN, devName, strlen(devName)), EOK);
875 ret = LnnSetDLUnifiedDeviceName(devUdid, devName);
876 EXPECT_EQ(ret, SOFTBUS_OK);
877 SoftBusFree(nodeInfo);
878 }
879
880 /*
881 * @tc.name: LNN_SET_DL_DEVICE_NICK_NAME_TEST_001
882 * @tc.desc: LnnSetDLDeviceNickName test
883 * @tc.type: FUNC
884 * @tc.require:
885 */
886 HWTEST_F(LNNDistributedNetLedgerManagerTest, LNN_SET_DL_DEVICE_NICK_NAME_TEST_001, TestSize.Level1)
887 {
888 NodeInfo *nodeInfo = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
889 ASSERT_NE(nodeInfo, nullptr);
890
891 LnnDistributedNetLedgerManagerInterfaceMock mock;
892 EXPECT_CALL(mock, LnnGetNodeInfoById).WillOnce(Return(nullptr)).WillRepeatedly(Return(nodeInfo));
893 const char *devNetworkId = "123456ABCDEF";
894 const char *devName = "deviceNickName";
895 bool ret = LnnSetDLDeviceNickName(nullptr, devName);
896 EXPECT_FALSE(ret);
897 ret = LnnSetDLDeviceNickName(devNetworkId, nullptr);
898 EXPECT_FALSE(ret);
899 ret = LnnSetDLDeviceNickName(devNetworkId, devName);
900 EXPECT_FALSE(ret);
901 ret = LnnSetDLDeviceNickName(devNetworkId, devName);
902 EXPECT_TRUE(ret);
903 SoftBusFree(nodeInfo);
904 }
905
906 /*
907 * @tc.name: LNN_SET_DL_DEVICE_INFO_NAME_TEST_001
908 * @tc.desc: LnnSetDLDeviceInfoName test
909 * @tc.type: FUNC
910 * @tc.require:
911 */
912 HWTEST_F(LNNDistributedNetLedgerManagerTest, LNN_SET_DL_DEVICE_INFO_NAME_TEST_001, TestSize.Level1)
913 {
914 NodeInfo *nodeInfo = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
915 ASSERT_NE(nodeInfo, nullptr);
916
917 LnnDistributedNetLedgerManagerInterfaceMock mock;
918 EXPECT_CALL(mock, GetNodeInfoFromMap).WillRepeatedly(Return(nodeInfo));
919 const char *devNetworkId = "123456ABCDEF";
920 const char *devName = "deviceNickName";
921 bool ret = LnnSetDLDeviceInfoName(nullptr, devName);
922 EXPECT_FALSE(ret);
923 ret = LnnSetDLDeviceInfoName(devNetworkId, nullptr);
924 EXPECT_FALSE(ret);
925 ret = LnnSetDLDeviceInfoName(devNetworkId, devName);
926 EXPECT_TRUE(ret);
927 ret = LnnSetDLDeviceInfoName(devNetworkId, devName);
928 EXPECT_TRUE(ret);
929
930 const char *devNameError = "abcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghij" \
931 "abcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghijabcdefghij";
932 ret = LnnSetDLDeviceInfoName(devNetworkId, devNameError);
933 EXPECT_FALSE(ret);
934 SoftBusFree(nodeInfo);
935 }
936
937 /*
938 * @tc.name: LNN_GET_REMOTE_NUM16_INFO_TEST_001
939 * @tc.desc: LnnGetRemoteNum16Info test
940 * @tc.type: FUNC
941 * @tc.require:
942 */
943 HWTEST_F(LNNDistributedNetLedgerManagerTest, LNN_GET_REMOTE_NUM16_INFO_TEST_001, TestSize.Level1)
944 {
945 NodeInfo *nodeInfo = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
946 ASSERT_NE(nodeInfo, nullptr);
947 LnnDistributedNetLedgerManagerInterfaceMock mock;
948 EXPECT_CALL(mock, LnnGetNodeInfoById).WillOnce(Return(nullptr)).WillOnce(Return(nodeInfo));
949
950 int16_t remoteCap = 0;
951 int32_t ret = LnnGetRemoteNum16Info(NODE_NETWORK_ID, NUM_KEY_DATA_CHANGE_FLAG, &remoteCap);
952 EXPECT_EQ(ret, SOFTBUS_NETWORK_GET_NODE_INFO_ERR);
953 ret = LnnGetRemoteNum16Info(NODE_NETWORK_ID, NUM_KEY_DATA_CHANGE_FLAG, &remoteCap);
954 EXPECT_EQ(ret, SOFTBUS_NETWORK_NODE_OFFLINE);
955 nodeInfo->status = STATUS_ONLINE;
956 EXPECT_CALL(mock, LnnGetNodeInfoById).WillOnce(Return(nodeInfo));
957 ret = LnnGetRemoteNum16Info(NODE_NETWORK_ID, NUM_KEY_DATA_CHANGE_FLAG, &remoteCap);
958 EXPECT_EQ(ret, SOFTBUS_NETWORK_NODE_OFFLINE);
959 SoftBusFree(nodeInfo);
960 }
961
962 /*
963 * @tc.name: LNN_GET_REMOTE_NUMU32_INFO_TEST_001
964 * @tc.desc: LnnGetRemoteNumU32Info test
965 * @tc.type: FUNC
966 * @tc.require:
967 */
968 HWTEST_F(LNNDistributedNetLedgerManagerTest, LNN_GET_REMOTE_NUMU32_INFO_TEST_001, TestSize.Level1)
969 {
970 uint32_t remoteCap = 0;
971 int32_t ret = LnnGetRemoteNumU32Info(nullptr, NUM_KEY_NET_CAP, &remoteCap);
972 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
973 ret = LnnGetRemoteNumU32Info(NODE_NETWORK_ID, NUM_KEY_NET_CAP, nullptr);
974 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
975 ret = LnnGetRemoteNumU32Info(NODE_NETWORK_ID, INFO_KEY_MAX, &remoteCap);
976 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
977 ret = LnnGetRemoteNumU32Info(NODE_NETWORK_ID, NUM_KEY_CONN_SUB_FEATURE_CAPA, &remoteCap);
978 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
979 }
980
981 /*
982 * @tc.name: LNN_GET_REMOTE_NUMU32_INFO_TEST_002
983 * @tc.desc: LnnGetRemoteNumU32Info test parameters is NUM_KEY_STA_FREQUENCY
984 * @tc.type: FUNC
985 * @tc.require:
986 */
987 HWTEST_F(LNNDistributedNetLedgerManagerTest, LNN_GET_REMOTE_NUMU32_INFO_TEST_002, TestSize.Level1)
988 {
989 NodeInfo *nodeInfo = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
990 ASSERT_NE(nodeInfo, nullptr);
991 LnnDistributedNetLedgerManagerInterfaceMock mock;
992 EXPECT_CALL(mock, LnnGetNodeInfoById).WillOnce(Return(nullptr)).WillOnce(Return(nodeInfo));
993
994 uint32_t remoteCap = 0;
995 nodeInfo->metaInfo.isMetaNode = false;
996 int32_t ret = LnnGetRemoteNumU32Info(NODE_NETWORK_ID, NUM_KEY_STA_FREQUENCY, &remoteCap);
997 EXPECT_EQ(ret, SOFTBUS_NETWORK_GET_NODE_INFO_ERR);
998 ret = LnnGetRemoteNumU32Info(NODE_NETWORK_ID, NUM_KEY_STA_FREQUENCY, &remoteCap);
999 EXPECT_EQ(ret, SOFTBUS_NETWORK_NODE_OFFLINE);
1000 nodeInfo->status = STATUS_ONLINE;
1001 EXPECT_CALL(mock, LnnGetNodeInfoById).WillOnce(Return(nodeInfo));
1002 ret = LnnGetRemoteNumU32Info(NODE_NETWORK_ID, NUM_KEY_STA_FREQUENCY, &remoteCap);
1003 EXPECT_EQ(ret, SOFTBUS_NETWORK_NODE_OFFLINE);
1004 SoftBusFree(nodeInfo);
1005 }
1006
1007 /*
1008 * @tc.name: LNN_GET_REMOTE_NUMU32_INFO_TEST_003
1009 * @tc.desc: LnnGetRemoteNumU32Info test parameters is NUM_KEY_STATE_VERSION
1010 * @tc.type: FUNC
1011 * @tc.require:
1012 */
1013 HWTEST_F(LNNDistributedNetLedgerManagerTest, LNN_GET_REMOTE_NUMU32_INFO_TEST_003, TestSize.Level1)
1014 {
1015 NodeInfo *nodeInfo = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
1016 ASSERT_NE(nodeInfo, nullptr);
1017 LnnDistributedNetLedgerManagerInterfaceMock mock;
1018 EXPECT_CALL(mock, LnnGetNodeInfoById).WillOnce(Return(nullptr)).WillOnce(Return(nodeInfo));
1019
1020 uint32_t remoteCap = 0;
1021 nodeInfo->stateVersion = 0;
1022 int32_t ret = LnnGetRemoteNumU32Info(NODE_NETWORK_ID, NUM_KEY_STATE_VERSION, &remoteCap);
1023 EXPECT_EQ(ret, SOFTBUS_NETWORK_GET_NODE_INFO_ERR);
1024 ret = LnnGetRemoteNumU32Info(NODE_NETWORK_ID, NUM_KEY_STATE_VERSION, &remoteCap);
1025 EXPECT_EQ(ret, SOFTBUS_NETWORK_NODE_OFFLINE);
1026 nodeInfo->status = STATUS_ONLINE;
1027 EXPECT_CALL(mock, LnnGetNodeInfoById).WillOnce(Return(nodeInfo));
1028 ret = LnnGetRemoteNumU32Info(NODE_NETWORK_ID, NUM_KEY_STATE_VERSION, &remoteCap);
1029 EXPECT_EQ(ret, SOFTBUS_NETWORK_NODE_OFFLINE);
1030 SoftBusFree(nodeInfo);
1031 }
1032
1033 /*
1034 * @tc.name: LNN_GET_REMOTE_NUMU32_INFO_TEST_004
1035 * @tc.desc: LnnGetRemoteNumU32Info test parameters is NUM_KEY_P2P_ROLE
1036 * @tc.type: FUNC
1037 * @tc.require:
1038 */
1039 HWTEST_F(LNNDistributedNetLedgerManagerTest, LNN_GET_REMOTE_NUMU32_INFO_TEST_004, TestSize.Level1)
1040 {
1041 NodeInfo *nodeInfo = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
1042 ASSERT_NE(nodeInfo, nullptr);
1043 LnnDistributedNetLedgerManagerInterfaceMock mock;
1044 EXPECT_CALL(mock, LnnGetNodeInfoById).WillOnce(Return(nullptr)).WillOnce(Return(nodeInfo));
1045
1046 uint32_t remoteCap = 0;
1047 nodeInfo->metaInfo.isMetaNode = false;
1048 int32_t ret = LnnGetRemoteNumU32Info(NODE_NETWORK_ID, NUM_KEY_P2P_ROLE, &remoteCap);
1049 EXPECT_EQ(ret, SOFTBUS_NETWORK_GET_NODE_INFO_ERR);
1050 ret = LnnGetRemoteNumU32Info(NODE_NETWORK_ID, NUM_KEY_P2P_ROLE, &remoteCap);
1051 EXPECT_EQ(ret, SOFTBUS_NETWORK_NODE_OFFLINE);
1052 nodeInfo->status = STATUS_ONLINE;
1053 EXPECT_CALL(mock, LnnGetNodeInfoById).WillOnce(Return(nodeInfo));
1054 ret = LnnGetRemoteNumU32Info(NODE_NETWORK_ID, NUM_KEY_P2P_ROLE, &remoteCap);
1055 EXPECT_EQ(ret, SOFTBUS_NETWORK_NODE_OFFLINE);
1056 SoftBusFree(nodeInfo);
1057 }
1058
1059 /*
1060 * @tc.name: LNN_GET_REMOTE_NUMU32_INFO_TEST_005
1061 * @tc.desc: LnnGetRemoteNumU32Info test parameters is NUM_KEY_DEVICE_SECURITY_LEVEL
1062 * @tc.type: FUNC
1063 * @tc.require:
1064 */
1065 HWTEST_F(LNNDistributedNetLedgerManagerTest, LNN_GET_REMOTE_NUMU32_INFO_TEST_005, TestSize.Level1)
1066 {
1067 NodeInfo *nodeInfo = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
1068 ASSERT_NE(nodeInfo, nullptr);
1069 LnnDistributedNetLedgerManagerInterfaceMock mock;
1070 EXPECT_CALL(mock, LnnGetNodeInfoById).WillRepeatedly(Return(nodeInfo));
1071
1072 uint32_t remoteCap = 0;
1073 int32_t ret = LnnGetRemoteNumU32Info(NODE_NETWORK_ID, NUM_KEY_DEVICE_SECURITY_LEVEL, &remoteCap);
1074 EXPECT_EQ(ret, SOFTBUS_OK);
1075 SoftBusFree(nodeInfo);
1076 }
1077
1078 /*
1079 * @tc.name: LNN_GET_REMOTE_NUMU32_INFO_TEST_006
1080 * @tc.desc: LnnGetRemoteNumU32Info test parameters is NUM_KEY_STATIC_CAP_LEN
1081 * @tc.type: FUNC
1082 * @tc.require:
1083 */
1084 HWTEST_F(LNNDistributedNetLedgerManagerTest, LNN_GET_REMOTE_NUMU32_INFO_TEST_006, TestSize.Level1)
1085 {
1086 NodeInfo *nodeInfo = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
1087 ASSERT_NE(nodeInfo, nullptr);
1088 LnnDistributedNetLedgerManagerInterfaceMock mock;
1089 EXPECT_CALL(mock, LnnGetNodeInfoById).WillOnce(Return(nodeInfo));
1090
1091 uint32_t remoteCap = 0;
1092 nodeInfo->metaInfo.isMetaNode = false;
1093 int32_t ret = LnnGetRemoteNumU32Info(NODE_NETWORK_ID, NUM_KEY_STATIC_CAP_LEN, &remoteCap);
1094 EXPECT_EQ(ret, SOFTBUS_NETWORK_NODE_OFFLINE);
1095 nodeInfo->status = STATUS_ONLINE;
1096 EXPECT_CALL(mock, LnnGetNodeInfoById).WillOnce(Return(nodeInfo));
1097 ret = LnnGetRemoteNumU32Info(NODE_NETWORK_ID, NUM_KEY_STATIC_CAP_LEN, &remoteCap);
1098 EXPECT_EQ(ret, SOFTBUS_NETWORK_NODE_OFFLINE);
1099 SoftBusFree(nodeInfo);
1100 }
1101
1102 /*
1103 * @tc.name: LNN_GET_REMOTE_NUMU32_INFO_TEST_007
1104 * @tc.desc: LnnGetRemoteNumU32Info test parameters is NUM_KEY_STATIC_NET_CAP
1105 * @tc.type: FUNC
1106 * @tc.require:
1107 */
1108 HWTEST_F(LNNDistributedNetLedgerManagerTest, LNN_GET_REMOTE_NUMU32_INFO_TEST_007, TestSize.Level1)
1109 {
1110 NodeInfo *nodeInfo = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
1111 ASSERT_NE(nodeInfo, nullptr);
1112 LnnDistributedNetLedgerManagerInterfaceMock mock;
1113 EXPECT_CALL(mock, LnnGetNodeInfoById).WillOnce(Return(nullptr)).WillRepeatedly(Return(nodeInfo));
1114
1115 uint32_t remoteCap = 0;
1116 int32_t ret = LnnGetRemoteNumU32Info(NODE_NETWORK_ID, NUM_KEY_STATIC_NET_CAP, &remoteCap);
1117 EXPECT_EQ(ret, SOFTBUS_NETWORK_GET_NODE_INFO_ERR);
1118 nodeInfo->staticNetCap = 10;
1119 ret = LnnGetRemoteNumU32Info(NODE_NETWORK_ID, NUM_KEY_STATIC_NET_CAP, &remoteCap);
1120 EXPECT_EQ(ret, SOFTBUS_OK);
1121 SoftBusFree(nodeInfo);
1122 }
1123
1124 /*
1125 * @tc.name: LNN_GET_REMOTE_STR_INFO_TEST_001
1126 * @tc.desc: LnnGetRemoteStrInfo test parameters is STRING_KEY_CHAN_LIST_5G
1127 * @tc.type: FUNC
1128 * @tc.require:
1129 */
1130 HWTEST_F(LNNDistributedNetLedgerManagerTest, LNN_GET_REMOTE_STR_INFO_TEST_001, TestSize.Level1)
1131 {
1132 NodeInfo *nodeInfo = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
1133 ASSERT_NE(nodeInfo, nullptr);
1134 LnnDistributedNetLedgerManagerInterfaceMock mock;
1135 EXPECT_CALL(mock, LnnGetNodeInfoById).WillOnce(Return(nullptr)).WillOnce(Return(nodeInfo));
1136
1137 char udid[UDID_BUF_LEN] = {0};
1138 nodeInfo->metaInfo.isMetaNode = false;
1139 int32_t ret = LnnGetRemoteStrInfo(NODE_NETWORK_ID, STRING_KEY_CHAN_LIST_5G, udid, sizeof(udid));
1140 EXPECT_EQ(ret, SOFTBUS_NETWORK_GET_NODE_INFO_ERR);
1141 ret = LnnGetRemoteStrInfo(NODE_NETWORK_ID, STRING_KEY_CHAN_LIST_5G, udid, sizeof(udid));
1142 EXPECT_EQ(ret, SOFTBUS_NETWORK_NODE_OFFLINE);
1143 nodeInfo->status = STATUS_ONLINE;
1144 EXPECT_CALL(mock, LnnGetNodeInfoById).WillOnce(Return(nodeInfo));
1145 ret = LnnGetRemoteStrInfo(NODE_NETWORK_ID, STRING_KEY_CHAN_LIST_5G, udid, sizeof(udid));
1146 EXPECT_EQ(ret, SOFTBUS_NETWORK_NODE_OFFLINE);
1147 SoftBusFree(nodeInfo);
1148 }
1149
1150 /*
1151 * @tc.name: LNN_GET_REMOTE_STR_INFO_TEST_002
1152 * @tc.desc: LnnGetRemoteStrInfo test parameters is STRING_KEY_WIFI_CFG
1153 * @tc.type: FUNC
1154 * @tc.require:
1155 */
1156 HWTEST_F(LNNDistributedNetLedgerManagerTest, LNN_GET_REMOTE_STR_INFO_TEST_002, TestSize.Level1)
1157 {
1158 NodeInfo *nodeInfo = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
1159 ASSERT_NE(nodeInfo, nullptr);
1160 LnnDistributedNetLedgerManagerInterfaceMock mock;
1161 EXPECT_CALL(mock, LnnGetNodeInfoById).WillOnce(Return(nullptr)).WillOnce(Return(nodeInfo));
1162
1163 char udid[UDID_BUF_LEN] = {0};
1164 nodeInfo->metaInfo.isMetaNode = false;
1165 int32_t ret = LnnGetRemoteStrInfo(NODE_NETWORK_ID, STRING_KEY_WIFI_CFG, udid, sizeof(udid));
1166 EXPECT_EQ(ret, SOFTBUS_NETWORK_GET_NODE_INFO_ERR);
1167 ret = LnnGetRemoteStrInfo(NODE_NETWORK_ID, STRING_KEY_WIFI_CFG, udid, sizeof(udid));
1168 EXPECT_EQ(ret, SOFTBUS_NETWORK_NODE_OFFLINE);
1169 nodeInfo->status = STATUS_ONLINE;
1170 EXPECT_CALL(mock, LnnGetNodeInfoById).WillOnce(Return(nodeInfo));
1171 ret = LnnGetRemoteStrInfo(NODE_NETWORK_ID, STRING_KEY_WIFI_CFG, udid, sizeof(udid));
1172 EXPECT_EQ(ret, SOFTBUS_NETWORK_NODE_OFFLINE);
1173 SoftBusFree(nodeInfo);
1174 }
1175
1176 /*
1177 * @tc.name: LNN_GET_REMOTE_STR_INFO_TEST_003
1178 * @tc.desc: LnnGetRemoteStrInfo test parameters is STRING_KEY_P2P_GO_MAC
1179 * @tc.type: FUNC
1180 * @tc.require:
1181 */
1182 HWTEST_F(LNNDistributedNetLedgerManagerTest, LNN_GET_REMOTE_STR_INFO_TEST_003, TestSize.Level1)
1183 {
1184 NodeInfo *nodeInfo = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
1185 ASSERT_NE(nodeInfo, nullptr);
1186 LnnDistributedNetLedgerManagerInterfaceMock mock;
1187 EXPECT_CALL(mock, LnnGetNodeInfoById).WillOnce(Return(nullptr)).WillOnce(Return(nodeInfo));
1188
1189 char udid[UDID_BUF_LEN] = {0};
1190 nodeInfo->metaInfo.isMetaNode = false;
1191 int32_t ret = LnnGetRemoteStrInfo(NODE_NETWORK_ID, STRING_KEY_P2P_GO_MAC, udid, sizeof(udid));
1192 EXPECT_EQ(ret, SOFTBUS_NETWORK_GET_NODE_INFO_ERR);
1193 ret = LnnGetRemoteStrInfo(NODE_NETWORK_ID, STRING_KEY_P2P_GO_MAC, udid, sizeof(udid));
1194 EXPECT_EQ(ret, SOFTBUS_NETWORK_NODE_OFFLINE);
1195 nodeInfo->status = STATUS_ONLINE;
1196 EXPECT_CALL(mock, LnnGetNodeInfoById).WillOnce(Return(nodeInfo));
1197 ret = LnnGetRemoteStrInfo(NODE_NETWORK_ID, STRING_KEY_P2P_GO_MAC, udid, sizeof(udid));
1198 EXPECT_EQ(ret, SOFTBUS_NETWORK_NODE_OFFLINE);
1199 SoftBusFree(nodeInfo);
1200 }
1201
1202 /*
1203 * @tc.name: LNN_GET_REMOTE_STR_INFO_TEST_004
1204 * @tc.desc: LnnGetRemoteStrInfo test parameters is STRING_KEY_NODE_ADDR
1205 * @tc.type: FUNC
1206 * @tc.require:
1207 */
1208 HWTEST_F(LNNDistributedNetLedgerManagerTest, LNN_GET_REMOTE_STR_INFO_TEST_004, TestSize.Level1)
1209 {
1210 NodeInfo *nodeInfo = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
1211 ASSERT_NE(nodeInfo, nullptr);
1212 LnnDistributedNetLedgerManagerInterfaceMock mock;
1213 EXPECT_CALL(mock, LnnGetNodeInfoById).WillOnce(Return(nullptr)).WillOnce(Return(nodeInfo));
1214
1215 char udid[UDID_BUF_LEN] = {0};
1216 int32_t ret = LnnGetRemoteStrInfo(NODE_NETWORK_ID, STRING_KEY_NODE_ADDR, udid, sizeof(udid));
1217 EXPECT_EQ(ret, SOFTBUS_NETWORK_GET_NODE_INFO_ERR);
1218 ret = LnnGetRemoteStrInfo(NODE_NETWORK_ID, STRING_KEY_NODE_ADDR, udid, sizeof(udid));
1219 EXPECT_EQ(ret, SOFTBUS_NETWORK_NODE_OFFLINE);
1220 nodeInfo->status = STATUS_ONLINE;
1221 EXPECT_CALL(mock, LnnGetNodeInfoById).WillOnce(Return(nodeInfo));
1222 ret = LnnGetRemoteStrInfo(NODE_NETWORK_ID, STRING_KEY_NODE_ADDR, udid, sizeof(udid));
1223 EXPECT_EQ(ret, SOFTBUS_NETWORK_NODE_OFFLINE);
1224 SoftBusFree(nodeInfo);
1225 }
1226
1227 /*
1228 * @tc.name: LNN_GET_REMOTE_STR_INFO_TEST_005
1229 * @tc.desc: LnnGetRemoteStrInfo test parameters is STRING_KEY_WIFIDIRECT_ADDR
1230 * @tc.type: FUNC
1231 * @tc.require:
1232 */
1233 HWTEST_F(LNNDistributedNetLedgerManagerTest, LNN_GET_REMOTE_STR_INFO_TEST_005, TestSize.Level1)
1234 {
1235 NodeInfo *nodeInfo = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
1236 ASSERT_NE(nodeInfo, nullptr);
1237 LnnDistributedNetLedgerManagerInterfaceMock mock;
1238 EXPECT_CALL(mock, LnnGetNodeInfoById).WillOnce(Return(nullptr)).WillOnce(Return(nodeInfo));
1239
1240 char udid[UDID_BUF_LEN] = {0};
1241 nodeInfo->metaInfo.isMetaNode = false;
1242 int32_t ret = LnnGetRemoteStrInfo(NODE_NETWORK_ID, STRING_KEY_WIFIDIRECT_ADDR, udid, sizeof(udid));
1243 EXPECT_EQ(ret, SOFTBUS_NETWORK_GET_NODE_INFO_ERR);
1244 ret = LnnGetRemoteStrInfo(NODE_NETWORK_ID, STRING_KEY_WIFIDIRECT_ADDR, udid, sizeof(udid));
1245 EXPECT_EQ(ret, SOFTBUS_NETWORK_NODE_OFFLINE);
1246 nodeInfo->status = STATUS_ONLINE;
1247 EXPECT_CALL(mock, LnnGetNodeInfoById).WillOnce(Return(nodeInfo));
1248 ret = LnnGetRemoteStrInfo(NODE_NETWORK_ID, STRING_KEY_WIFIDIRECT_ADDR, udid, sizeof(udid));
1249 EXPECT_EQ(ret, SOFTBUS_NETWORK_NODE_OFFLINE);
1250 SoftBusFree(nodeInfo);
1251 }
1252
1253 /*
1254 * @tc.name: LNN_GET_REMOTE_STR_INFO_TEST_006
1255 * @tc.desc: LnnGetRemoteStrInfo test parameters is STRING_KEY_P2P_MAC
1256 * @tc.type: FUNC
1257 * @tc.require:
1258 */
1259 HWTEST_F(LNNDistributedNetLedgerManagerTest, LNN_GET_REMOTE_STR_INFO_TEST_006, TestSize.Level1)
1260 {
1261 NodeInfo *nodeInfo = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
1262 ASSERT_NE(nodeInfo, nullptr);
1263 LnnDistributedNetLedgerManagerInterfaceMock mock;
1264 EXPECT_CALL(mock, LnnGetNodeInfoById).WillOnce(Return(nullptr)).WillOnce(Return(nodeInfo));
1265
1266 char udid[UDID_BUF_LEN] = {0};
1267 nodeInfo->metaInfo.isMetaNode = false;
1268 int32_t ret = LnnGetRemoteStrInfo(NODE_NETWORK_ID, STRING_KEY_P2P_MAC, udid, sizeof(udid));
1269 EXPECT_EQ(ret, SOFTBUS_NETWORK_GET_NODE_INFO_ERR);
1270 ret = LnnGetRemoteStrInfo(NODE_NETWORK_ID, STRING_KEY_P2P_MAC, udid, sizeof(udid));
1271 EXPECT_EQ(ret, SOFTBUS_NETWORK_NODE_OFFLINE);
1272 nodeInfo->status = STATUS_ONLINE;
1273 EXPECT_CALL(mock, LnnGetNodeInfoById).WillOnce(Return(nodeInfo));
1274 ret = LnnGetRemoteStrInfo(NODE_NETWORK_ID, STRING_KEY_P2P_MAC, udid, sizeof(udid));
1275 EXPECT_EQ(ret, SOFTBUS_NETWORK_NODE_OFFLINE);
1276 SoftBusFree(nodeInfo);
1277 }
1278
1279 /*
1280 * @tc.name: LNN_GET_REMOTE_NUM64_INFO_TEST_001
1281 * @tc.desc: LnnGetRemoteNumU64Info test parameters is NUM_KEY_P2P_ROLE
1282 * @tc.type: FUNC
1283 * @tc.require:
1284 */
1285 HWTEST_F(LNNDistributedNetLedgerManagerTest, LNN_GET_REMOTE_NUM64_INFO_TEST_001, TestSize.Level1)
1286 {
1287 uint64_t remoteCap = 0;
1288 int32_t ret = LnnGetRemoteNumU64Info(NODE_NETWORK_ID, NUM_KEY_END, &remoteCap);
1289 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1290 ret = LnnGetRemoteNumU64Info(NODE_NETWORK_ID, NUM_KEY_STATIC_NET_CAP, &remoteCap);
1291 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1292 ret = LnnGetRemoteNumU64Info(NODE_NETWORK_ID, NUM_KEY_NET_CAP, &remoteCap);
1293 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1294 ret = LnnGetRemoteNumU64Info(NODE_NETWORK_ID, NUM_KEY_DEVICE_SECURITY_LEVEL, &remoteCap);
1295 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1296 }
1297
1298 /*
1299 * @tc.name: DL_GET_CONN_SUB_FEATURE_CAP_TEST_001
1300 * @tc.desc: DlGetConnSubFeatureCap test
1301 * @tc.type: FUNC
1302 * @tc.require:
1303 */
1304 HWTEST_F(LNNDistributedNetLedgerManagerTest, DL_GET_CONN_SUB_FEATURE_CAP_TEST_001, TestSize.Level1)
1305 {
1306 NodeInfo *nodeInfo = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
1307 ASSERT_NE(nodeInfo, nullptr);
1308 LnnDistributedNetLedgerManagerInterfaceMock mock;
1309 EXPECT_CALL(mock, LnnGetNodeInfoById).WillRepeatedly(Return(nodeInfo));
1310
1311 uint64_t remoteCap = DEFAULT_VALUE;
1312 nodeInfo->connSubFeature = DEFAULT_VALUE;
1313 int32_t ret = LnnGetRemoteNumU64Info(NODE_NETWORK_ID, NUM_KEY_CONN_SUB_FEATURE_CAPA, &remoteCap);
1314 EXPECT_EQ(ret, SOFTBUS_OK);
1315 SoftBusFree(nodeInfo);
1316 }
1317
1318 /*
1319 * @tc.name: LNN_SET_REMOTE_SCREEN_STATUS_INFO_TEST_001
1320 * @tc.desc: LnnSetRemoteScreenStatusInfo test
1321 * @tc.type: FUNC
1322 * @tc.require:
1323 */
1324 HWTEST_F(LNNDistributedNetLedgerManagerTest, LNN_SET_REMOTE_SCREEN_STATUS_INFO_TEST_001, TestSize.Level1)
1325 {
1326 NodeInfo *nodeInfo = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
1327 ASSERT_NE(nodeInfo, nullptr);
1328 LnnDistributedNetLedgerManagerInterfaceMock mock;
1329 EXPECT_CALL(mock, LnnGetNodeInfoById).WillOnce(Return(nullptr)).WillRepeatedly(Return(nodeInfo));
1330
1331 const char *devNetworkId = "123456789";
1332 bool isScreenOn = false;
1333 bool ret = LnnSetRemoteScreenStatusInfo(nullptr, isScreenOn);
1334 EXPECT_FALSE(ret);
1335 ret = LnnSetRemoteScreenStatusInfo(devNetworkId, isScreenOn);
1336 EXPECT_FALSE(ret);
1337 nodeInfo->heartbeatCapacity = 0;
1338 ret = LnnSetRemoteScreenStatusInfo(devNetworkId, isScreenOn);
1339 EXPECT_FALSE(ret);
1340 nodeInfo->heartbeatCapacity = 63;
1341 ret = LnnSetRemoteScreenStatusInfo(devNetworkId, isScreenOn);
1342 EXPECT_TRUE(ret);
1343 SoftBusFree(nodeInfo);
1344 }
1345 } // namespace OHOS
1346