1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17 #include <securec.h>
18
19 #include "bus_center_info_key.h"
20 #include "bus_center_manager.h"
21 #include "lnn_distributed_net_ledger.h"
22 #include "lnn_lane.h"
23 #include "lnn_lane_link.h"
24 #include "lnn_lane_reliability.h"
25 #include "lnn_lane_select.h"
26 #include "lnn_local_net_ledger.h"
27 #include "message_handler.h"
28 #include "softbus_adapter_mem.h"
29 #include "softbus_adapter_timer.h"
30 #include "softbus_errcode.h"
31 #include "softbus_utils.h"
32 #include "lnn_parameter_utils.h"
33
34 namespace OHOS {
35 using namespace testing::ext;
36 using namespace testing;
37 constexpr char NODE_NETWORK_ID[] = "111122223333abcdef";
38 constexpr char NODE_UDID[] = "123456ABCDEF";
39 constexpr char NODE_BT_MAC[] = "b1:ab:cd:ef:aa:d7";
40 constexpr uint32_t REMOTE_SESSION_PORT = 6060;
41 constexpr uint32_t REMOTE_AUTH_PORT = 7070;
42 constexpr uint32_t REMOTE_PROXY_PORT = 8080;
43 constexpr char REMOTE_WLAN_IP[] = "10.146.181.134";
44 constexpr char LOCAL_NETWORK_ID[] = "444455556666abcdef";
45 constexpr uint32_t LANE_PREFERRED_LINK_NUM = 2;
46 constexpr uint32_t DEFAULT_QOSINFO_MIN_BW = 10;
47 constexpr uint32_t DEFAULT_QOSINFO_MAX_LATENCY = 10000;
48 constexpr uint32_t DEFAULT_QOSINFO_MIN_LATENCY = 2500;
49 constexpr uint32_t LOW_BW = 500 * 1024;
50 constexpr uint32_t HIGH_BW = 160 * 1024 * 1024;
51 constexpr uint32_t LANE_REQ_ID_TYPE_SHIFT = 28;
52 constexpr uint64_t LANE_ID = 123456;
53
54 static NodeInfo g_nodeInfo;
55 constexpr int32_t DEFAULT_PID = 0;
56
57 static void ConstructRemoteNode(void);
58 static void ConstructLocalInfo(void);
59
60 class LaneTest : public testing::Test {
61 public:
62 static void SetUpTestCase();
63 static void TearDownTestCase();
64 void SetUp();
65 void TearDown();
66 };
67
SetUpTestCase()68 void LaneTest::SetUpTestCase()
69 {
70 int32_t ret = LnnInitLnnLooper();
71 EXPECT_TRUE(ret == SOFTBUS_OK);
72 ret = LooperInit();
73 EXPECT_TRUE(ret == SOFTBUS_OK);
74 ret = LnnInitDistributedLedger();
75 EXPECT_TRUE(ret == SOFTBUS_OK);
76 ret = LnnInitLocalLedger();
77 EXPECT_TRUE(ret == SOFTBUS_OK);
78 ret = InitLane();
79 EXPECT_TRUE(ret == SOFTBUS_OK);
80 ConstructRemoteNode();
81 ConstructLocalInfo();
82 GTEST_LOG_(INFO) << "LaneTest start";
83 }
84
TearDownTestCase()85 void LaneTest::TearDownTestCase()
86 {
87 DeinitLane();
88 LnnDeinitLocalLedger();
89 LnnDeinitDistributedLedger();
90 LooperDeinit();
91 LnnDeinitLnnLooper();
92 (void)memset_s(&g_nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
93 GTEST_LOG_(INFO) << "LaneTest end";
94 }
95
SetUp()96 void LaneTest::SetUp()
97 {
98 }
99
TearDown()100 void LaneTest::TearDown()
101 {
102 }
103
ConstructRemoteNode(void)104 static void ConstructRemoteNode(void)
105 {
106 (void)memset_s(&g_nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
107 uint32_t cap = 0;
108 LnnSetNetCapability(&cap, BIT_BR);
109 LnnSetNetCapability(&cap, BIT_WIFI_P2P);
110 LnnSetNetCapability(&cap, BIT_WIFI_24G);
111 LnnSetNetCapability(&cap, BIT_WIFI_5G);
112 g_nodeInfo.netCapacity = cap;
113 int32_t ret = strncpy_s(g_nodeInfo.networkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID, strlen(NODE_NETWORK_ID));
114 EXPECT_TRUE(ret == EOK);
115 ret = LnnSetDeviceUdid(&g_nodeInfo, NODE_UDID);
116 EXPECT_TRUE(ret == SOFTBUS_OK);
117 ret = LnnSetDiscoveryType(&g_nodeInfo, DISCOVERY_TYPE_WIFI);
118 EXPECT_TRUE(ret == SOFTBUS_OK);
119 ret = LnnSetProxyPort(&g_nodeInfo, REMOTE_PROXY_PORT);
120 EXPECT_TRUE(ret == SOFTBUS_OK);
121 ret = LnnSetSessionPort(&g_nodeInfo, REMOTE_SESSION_PORT);
122 EXPECT_TRUE(ret == SOFTBUS_OK);
123 LnnSetWiFiIp(&g_nodeInfo, REMOTE_WLAN_IP);
124 ret = LnnSetAuthPort(&g_nodeInfo, REMOTE_AUTH_PORT);
125 EXPECT_TRUE(ret == SOFTBUS_OK);
126 LnnSetBtMac(&g_nodeInfo, NODE_BT_MAC);
127 (void)LnnAddOnlineNode(&g_nodeInfo);
128 }
129
ConstructLocalInfo(void)130 static void ConstructLocalInfo(void)
131 {
132 int32_t ret = LnnSetLocalStrInfo(STRING_KEY_NETWORKID, LOCAL_NETWORK_ID);
133 EXPECT_TRUE(ret == SOFTBUS_OK);
134 ret = LnnSetLocalNumInfo(NUM_KEY_NET_CAP, (1 << BIT_BR) |
135 (1 << BIT_WIFI_24G) | (1 << BIT_WIFI_5G) | (1 << BIT_WIFI_P2P));
136 EXPECT_TRUE(ret == SOFTBUS_OK);
137 }
138
NotifyWlanLinkSuccess(uint32_t reqId,LaneLinkType linkType,const LaneLinkInfo * linkInfo)139 static void NotifyWlanLinkSuccess(uint32_t reqId, LaneLinkType linkType, const LaneLinkInfo *linkInfo)
140 {
141 EXPECT_TRUE((linkInfo->type == LANE_WLAN_2P4G) || (linkInfo->type == LANE_WLAN_5G));
142 EXPECT_EQ(linkInfo->linkInfo.wlan.connInfo.port, REMOTE_SESSION_PORT);
143 EXPECT_STREQ(REMOTE_WLAN_IP, linkInfo->linkInfo.wlan.connInfo.addr);
144 printf("WLAN: linkSuccess, reqId:0x%x\n", reqId);
145 }
146
NotifyWlanLinkFail(uint32_t reqId,int32_t reason,LaneLinkType linkType)147 static void NotifyWlanLinkFail(uint32_t reqId, int32_t reason, LaneLinkType linkType)
148 {
149 printf("WLAN: reqId:0x%x, fail reason:%d, linkType:%d\n", reqId, reason, linkType);
150 }
151
NotifyBrLinkSuccess(uint32_t reqId,LaneLinkType linkType,const LaneLinkInfo * linkInfo)152 static void NotifyBrLinkSuccess(uint32_t reqId, LaneLinkType linkType, const LaneLinkInfo *linkInfo)
153 {
154 EXPECT_TRUE(linkInfo->type == LANE_BR);
155 EXPECT_STREQ(linkInfo->linkInfo.br.brMac, NODE_BT_MAC);
156 printf("BR: linkSuccess, reqId:0x%x\n", reqId);
157 }
158
NotifyBrLinkFail(uint32_t reqId,int32_t reason,LaneLinkType linkType)159 static void NotifyBrLinkFail(uint32_t reqId, int32_t reason, LaneLinkType linkType)
160 {
161 printf("BR: reqId:0x%x, fail reason:%d, linkType:%d\n", reqId, reason, linkType);
162 }
163
GetLinkType(LaneLinkType type)164 static const char *GetLinkType(LaneLinkType type)
165 {
166 switch (type) {
167 case LANE_BR:
168 return "BR";
169 case LANE_WLAN_2P4G:
170 return "Wlan_2.4G";
171 case LANE_WLAN_5G:
172 return "Wlan_5G";
173 case LANE_P2P:
174 return "P2P";
175 default:
176 return "Unknown-Link";
177 }
178 }
179
OnLaneAllocSuccess(uint32_t laneHandle,const LaneConnInfo * info)180 static void OnLaneAllocSuccess(uint32_t laneHandle, const LaneConnInfo *info)
181 {
182 printf("LaneAllocSucc: laneReqId:0x%x, linkType:%s\n", laneHandle, GetLinkType(info->type));
183 const LnnLaneManager *laneManager = GetLaneManager();
184 int32_t ret = laneManager->lnnFreeLane(laneHandle);
185 EXPECT_TRUE(ret == SOFTBUS_OK);
186 }
187
OnLaneAllocFail(uint32_t laneHandle,int32_t errCode)188 static void OnLaneAllocFail(uint32_t laneHandle, int32_t errCode)
189 {
190 printf("LaneAllocFail: laneReqId:0x%x, reason:%d\n", laneHandle, errCode);
191 const LnnLaneManager *laneManager = GetLaneManager();
192 int32_t ret = laneManager->lnnFreeLane(laneHandle);
193 EXPECT_TRUE(ret == SOFTBUS_OK);
194 }
195
OnLaneFreeSuccess(uint32_t laneHandle)196 static void OnLaneFreeSuccess(uint32_t laneHandle)
197 {
198 GTEST_LOG_(INFO) << "free lane success, laneReqId=" << laneHandle;
199 }
200
OnLaneFreeFail(uint32_t laneHandle,int32_t errCode)201 static void OnLaneFreeFail(uint32_t laneHandle, int32_t errCode)
202 {
203 GTEST_LOG_(INFO) << "free lane failed, laneReqId=" << laneHandle << ", errCode=" << errCode;
204 }
205
206 /*
207 * @tc.name: LANE_REQ_ID_APPLY_Test_001
208 * @tc.desc: apply laneReqId test
209 * @tc.type: FUNC
210 * @tc.require: I5FBFG
211 */
212 HWTEST_F(LaneTest, LANE_REQ_ID_APPLY_Test_001, TestSize.Level1)
213 {
214 const LnnLaneManager *laneManager = GetLaneManager();
215 LaneType laneType = LANE_TYPE_TRANS;
216 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
217 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
218 EXPECT_EQ(laneType, laneReqId >> LANE_REQ_ID_TYPE_SHIFT);
219 FreeLaneReqId(laneReqId);
220 }
221
222 /*
223 * @tc.name: LANE_REQ_ID_APPLY_Test_002
224 * @tc.desc: apply laneReqId test
225 * @tc.type: FUNC
226 * @tc.require: I5FBFG
227 */
228 HWTEST_F(LaneTest, LANE_REQ_ID_APPLY_Test_002, TestSize.Level1)
229 {
230 LaneType laneType = LANE_TYPE_TRANS;
231 uint32_t laneReqId;
232 uint32_t *laneReqIdList = (uint32_t *)SoftBusCalloc(sizeof(uint32_t) * MAX_LANE_REQ_ID_NUM);
233 if (laneReqIdList == nullptr) {
234 return;
235 }
236 const LnnLaneManager *laneManager = GetLaneManager();
237 uint32_t i;
238 for (i = 0; i < MAX_LANE_REQ_ID_NUM; i++) {
239 laneReqId = laneManager->lnnGetLaneHandle(laneType);
240 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
241 laneReqIdList[i] = laneReqId;
242 }
243 laneReqId = laneManager->lnnGetLaneHandle(laneType);
244 EXPECT_TRUE(laneReqId == INVALID_LANE_REQ_ID);
245 for (i = 0; i < MAX_LANE_REQ_ID_NUM; i++) {
246 FreeLaneReqId(laneReqIdList[i]);
247 }
248 SoftBusFree(laneReqIdList);
249 }
250
251 /*
252 * @tc.name: LANE_SELECT_Test_001
253 * @tc.desc: lane select fileTransLane by LNN
254 * @tc.type: FUNC
255 * @tc.require: I5FBFG
256 */
257 HWTEST_F(LaneTest, LANE_SELECT_Test_001, TestSize.Level1)
258 {
259 LanePreferredLinkList recommendList;
260 (void)memset_s(&recommendList, sizeof(LanePreferredLinkList), 0, sizeof(LanePreferredLinkList));
261 uint32_t listNum = 0;
262 LaneSelectParam selectParam;
263 (void)memset_s(&selectParam, sizeof(LaneSelectParam), 0, sizeof(LaneSelectParam));
264 selectParam.transType = LANE_T_FILE;
265 selectParam.expectedBw = 0;
266 int32_t ret = SelectLane(NODE_NETWORK_ID, &selectParam, &recommendList, &listNum);
267 EXPECT_EQ(ret, SOFTBUS_OK);
268 EXPECT_EQ(listNum, 4);
269 }
270
271 /*
272 * @tc.name: EXPECT_LANE_SELECT_BY_QOS_Test_001
273 * @tc.desc: lane select fileTransLane by qos
274 * @tc.type: FUNC
275 * @tc.require: I5FBFG
276 */
277 HWTEST_F(LaneTest, EXPECT_LANE_SELECT_BY_QOS_Test_001, TestSize.Level1)
278 {
279 LanePreferredLinkList recommendList;
280 (void)memset_s(&recommendList, sizeof(LanePreferredLinkList), 0, sizeof(LanePreferredLinkList));
281 LaneSelectParam selectParam;
282 (void)memset_s(&selectParam, sizeof(LaneSelectParam), 0, sizeof(LaneSelectParam));
283 selectParam.transType = LANE_T_FILE;
284 selectParam.qosRequire.minBW = DEFAULT_QOSINFO_MIN_BW;
285 selectParam.qosRequire.maxLaneLatency = DEFAULT_QOSINFO_MAX_LATENCY;
286 selectParam.qosRequire.minLaneLatency = DEFAULT_QOSINFO_MIN_LATENCY;
287 int32_t ret = SelectExpectLanesByQos(NODE_NETWORK_ID, &selectParam, &recommendList);
288 EXPECT_EQ(ret, SOFTBUS_OK);
289 }
290
291 /*
292 * @tc.name: LANE_SELECT_Test_002
293 * @tc.desc: lane select by preferredLinkList
294 * @tc.type: FUNC
295 * @tc.require: I5FBFG
296 */
297 HWTEST_F(LaneTest, LANE_SELECT_Test_002, TestSize.Level1)
298 {
299 LanePreferredLinkList recommendList;
300 (void)memset_s(&recommendList, sizeof(LanePreferredLinkList), 0, sizeof(LanePreferredLinkList));
301 uint32_t listNum = 0;
302 LaneSelectParam selectParam;
303 (void)memset_s(&selectParam, sizeof(LaneSelectParam), 0, sizeof(LaneSelectParam));
304 selectParam.transType = LANE_T_BYTE;
305 selectParam.expectedBw = 0;
306 selectParam.list.linkTypeNum = LANE_PREFERRED_LINK_NUM;
307 selectParam.list.linkType[0] = LANE_WLAN_5G;
308 selectParam.list.linkType[1] = LANE_BR;
309 int32_t ret = SelectLane(NODE_NETWORK_ID, &selectParam, &recommendList, &listNum);
310 EXPECT_EQ(ret, SOFTBUS_OK);
311 EXPECT_EQ(listNum, 2);
312 }
313
314 /*
315 * @tc.name: EXPECT_LANE_SELECT_BY_QOS_Test_002
316 * @tc.desc: lane select BYTE TransLane by qos
317 * @tc.type: FUNC
318 * @tc.require: I5FBFG
319 */
320 HWTEST_F(LaneTest, EXPECT_LANE_SELECT_BY_QOS_Test_002, TestSize.Level1)
321 {
322 LanePreferredLinkList recommendList;
323 (void)memset_s(&recommendList, sizeof(LanePreferredLinkList), 0, sizeof(LanePreferredLinkList));
324 LaneSelectParam selectParam;
325 (void)memset_s(&selectParam, sizeof(LaneSelectParam), 0, sizeof(LaneSelectParam));
326 selectParam.transType = LANE_T_BYTE;
327 int32_t ret = SelectExpectLanesByQos(NODE_NETWORK_ID, &selectParam, &recommendList);
328 EXPECT_EQ(ret, SOFTBUS_OK);
329 }
330
331 /*
332 * @tc.name: LANE_LINK_Test_001
333 * @tc.desc: LaneLink of wlan5G
334 * @tc.type: FUNC
335 * @tc.require: I5FBFG
336 */
337 HWTEST_F(LaneTest, LANE_LINK_Test_001, TestSize.Level1)
338 {
339 ConnServerInit();
340 InitLaneReliability();
341 LinkRequest reqInfo;
342 (void)memset_s(&reqInfo, sizeof(LinkRequest), 0, sizeof(LinkRequest));
343 int32_t ret = memcpy_s(reqInfo.peerNetworkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID, strlen(NODE_NETWORK_ID));
344 EXPECT_TRUE(ret == EOK);
345 reqInfo.linkType = LANE_WLAN_2P4G;
346 reqInfo.transType = LANE_T_BYTE;
347 reqInfo.pid = DEFAULT_PID;
348 LaneLinkCb linkCb = {
349 .onLaneLinkSuccess = NotifyWlanLinkSuccess,
350 .onLaneLinkFail = NotifyWlanLinkFail,
351 };
352 uint32_t requestId = 0x5A5A;
353 ret = BuildLink(&reqInfo, requestId, &linkCb);
354 EXPECT_EQ(ret, SOFTBUS_TCPCONNECTION_SOCKET_ERR);
355 ConnServerDeinit();
356 }
357
358 /*
359 * @tc.name: LANE_LINK_Test_002
360 * @tc.desc: LaneLink of BR
361 * @tc.type: FUNC
362 * @tc.require: I5FBFG
363 */
364 HWTEST_F(LaneTest, LANE_LINK_Test_002, TestSize.Level1)
365 {
366 LinkRequest reqInfo;
367 (void)memset_s(&reqInfo, sizeof(LinkRequest), 0, sizeof(LinkRequest));
368 int32_t ret = memcpy_s(reqInfo.peerNetworkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID, strlen(NODE_NETWORK_ID));
369 EXPECT_EQ(ret, EOK);
370 reqInfo.linkType = LANE_BR;
371 reqInfo.transType = LANE_T_BYTE;
372 reqInfo.pid = DEFAULT_PID;
373 LaneLinkCb linkCb = {
374 .onLaneLinkSuccess = NotifyBrLinkSuccess,
375 .onLaneLinkFail = NotifyBrLinkFail,
376 };
377 uint32_t requestId = 0x5A5A;
378 ret = BuildLink(&reqInfo, requestId, &linkCb);
379 EXPECT_EQ(ret, SOFTBUS_OK);
380 }
381
382 /*
383 * @tc.name: TRANS_LANE_ALLOC_Test_001
384 * @tc.desc: TransLaneRequest test
385 * @tc.type: FUNC
386 * @tc.require: I5FBFG
387 */
388 HWTEST_F(LaneTest, TRANS_LANE_ALLOC_Test_001, TestSize.Level1)
389 {
390 const LnnLaneManager *laneManager = GetLaneManager();
391 uint32_t laneReqId = laneManager->lnnGetLaneHandle(LANE_TYPE_TRANS);
392 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
393 LaneAllocInfo allocInfo;
394 (void)memset_s(&allocInfo, sizeof(LaneAllocInfo), 0, sizeof(LaneAllocInfo));
395 allocInfo.type = LANE_TYPE_TRANS;
396 allocInfo.transType = LANE_T_RAW_STREAM;
397 int32_t ret = memcpy_s(allocInfo.networkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID, sizeof(NODE_NETWORK_ID));
398 EXPECT_TRUE(ret == EOK);
399 allocInfo.pid = DEFAULT_PID;
400 allocInfo.qosRequire.minBW = DEFAULT_QOSINFO_MIN_BW + HIGH_BW;
401 allocInfo.qosRequire.maxLaneLatency = DEFAULT_QOSINFO_MAX_LATENCY;
402 allocInfo.qosRequire.minLaneLatency = DEFAULT_QOSINFO_MIN_LATENCY;
403 LaneAllocListener listener = {
404 .onLaneAllocSuccess = OnLaneAllocSuccess,
405 .onLaneAllocFail = OnLaneAllocFail,
406 .onLaneFreeSuccess = OnLaneFreeSuccess,
407 .onLaneFreeFail = OnLaneFreeFail,
408 };
409 ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &listener);
410 EXPECT_EQ(ret, SOFTBUS_OK);
411
412 laneReqId = laneManager->lnnGetLaneHandle(LANE_TYPE_TRANS);
413 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
414 allocInfo.qosRequire.minBW = DEFAULT_QOSINFO_MIN_BW + LOW_BW;
415 ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &listener);
416 EXPECT_EQ(ret, SOFTBUS_OK);
417 SoftBusSleepMs(5);
418 }
419
420 /*
421 * @tc.name: ADD_LANE_RESOURCE_TO_POOL_Test_001
422 * @tc.desc: AddLaneResourceToPool test
423 * @tc.type: FUNC
424 * @tc.require: I5FBFG
425 */
426 HWTEST_F(LaneTest, ADD_LANE_RESOURCE_TO_POOL_Test_001, TestSize.Level1)
427 {
428 LaneLinkInfo linkInfo = { .type = LANE_HML, };
429 EXPECT_EQ(strncpy_s(linkInfo.peerUdid, UDID_BUF_LEN, NODE_UDID, UDID_BUF_LEN), EOK);
430 EXPECT_EQ(strncpy_s(linkInfo.linkInfo.p2p.connInfo.peerIp, IP_LEN, REMOTE_WLAN_IP, IP_LEN), EOK);
431 EXPECT_EQ(AddLaneResourceToPool(&linkInfo, LANE_ID, true), SOFTBUS_OK);
432 linkInfo.type = LANE_BR;
433 EXPECT_EQ(strncpy_s(linkInfo.linkInfo.br.brMac, BT_MAC_LEN, NODE_BT_MAC, BT_MAC_LEN), EOK);
434 EXPECT_EQ(AddLaneResourceToPool(&linkInfo, LANE_ID, true), SOFTBUS_OK);
435 linkInfo.type = LANE_BLE;
436 EXPECT_EQ(strncpy_s(linkInfo.linkInfo.ble.bleMac, BT_MAC_LEN, NODE_BT_MAC, BT_MAC_LEN), EOK);
437 EXPECT_EQ(AddLaneResourceToPool(&linkInfo, LANE_ID, true), SOFTBUS_OK);
438 linkInfo.type = LANE_BLE_DIRECT;
439 EXPECT_EQ(strncpy_s(linkInfo.linkInfo.bleDirect.networkId,
440 NETWORK_ID_BUF_LEN, NODE_NETWORK_ID, NETWORK_ID_BUF_LEN), EOK);
441 EXPECT_EQ(AddLaneResourceToPool(&linkInfo, LANE_ID, true), SOFTBUS_OK);
442 linkInfo.type = LANE_WLAN_5G;
443 EXPECT_EQ(AddLaneResourceToPool(&linkInfo, LANE_ID, true), SOFTBUS_OK);
444 EXPECT_EQ(AddLaneResourceToPool(nullptr, LANE_ID, true), SOFTBUS_INVALID_PARAM);
445 EXPECT_EQ(AddLaneResourceToPool(&linkInfo, INVALID_LANE_ID, true), SOFTBUS_INVALID_PARAM);
446 }
447
448 /*
449 * @tc.name: CHECK_LANE_RESOURCE_NUM_BY_LINK_TYPE_Test_001
450 * @tc.desc: CheckLaneResourceNumByLinkType test
451 * @tc.type: FUNC
452 * @tc.require: I5FBFG
453 */
454 HWTEST_F(LaneTest, CHECK_LANE_RESOURCE_NUM_BY_LINK_TYPE_Test_001, TestSize.Level1)
455 {
456 const char *peerUdid = "123456ABCDEF";
457 EXPECT_EQ(InitLaneLink(), SOFTBUS_OK);
458 int32_t laneNum = 0;
459 EXPECT_EQ(CheckLaneResourceNumByLinkType(peerUdid, LANE_HML, &laneNum), SOFTBUS_NOT_FIND);
460 EXPECT_EQ(CheckLaneResourceNumByLinkType(nullptr, LANE_HML, &laneNum), SOFTBUS_INVALID_PARAM);
461 EXPECT_EQ(CheckLaneResourceNumByLinkType(peerUdid, LANE_LINK_TYPE_BUTT, &laneNum), SOFTBUS_INVALID_PARAM);
462 EXPECT_EQ(CheckLaneResourceNumByLinkType(peerUdid, LANE_HML_RAW, &laneNum), SOFTBUS_NOT_FIND);
463 }
464
465 /*
466 * @tc.name: UPDATE_LANE_RESOURCE_LANE_ID_Test_001
467 * @tc.desc: UpdateLaneResourceLaneId test
468 * @tc.type: FUNC
469 * @tc.require: I5FBFG
470 */
471 HWTEST_F(LaneTest, UPDATE_LANE_RESOURCE_LANE_ID_Test_001, TestSize.Level1)
472 {
473 uint64_t oldLaneId = LANE_ID;
474 uint64_t newLaneId = LANE_ID + 1;
475 const char *peerUdid = "123456ABCDEF";
476 const char *peerUdid1 = "123456ABCDEFGHIGK";
477 EXPECT_EQ(UpdateLaneResourceLaneId(oldLaneId, newLaneId, peerUdid), SOFTBUS_NOT_FIND);
478 EXPECT_EQ(UpdateLaneResourceLaneId(oldLaneId, newLaneId, peerUdid1), SOFTBUS_NOT_FIND);
479 EXPECT_EQ(UpdateLaneResourceLaneId(INVALID_LANE_ID, newLaneId, peerUdid1), SOFTBUS_INVALID_PARAM);
480 EXPECT_EQ(UpdateLaneResourceLaneId(oldLaneId, INVALID_LANE_ID, peerUdid1), SOFTBUS_INVALID_PARAM);
481 EXPECT_EQ(UpdateLaneResourceLaneId(oldLaneId, INVALID_LANE_ID, nullptr), SOFTBUS_INVALID_PARAM);
482 }
483
484 /*
485 * @tc.name: DESTROY_LINK_Test_001
486 * @tc.desc: DestroyLink test
487 * @tc.type: FUNC
488 * @tc.require: I5FBFG
489 */
490 HWTEST_F(LaneTest, DESTROY_LINK_Test_001, TestSize.Level1)
491 {
492 const char *networkId = "111122223333abcdef";
493 uint32_t laneReqId = LANE_REQ_ID_TYPE_SHIFT;
494 EXPECT_EQ(DestroyLink(networkId, laneReqId, LANE_P2P), SOFTBUS_LANE_RESOURCE_NOT_FOUND);
495 EXPECT_EQ(DestroyLink(nullptr, laneReqId, LANE_P2P), SOFTBUS_INVALID_PARAM);
496 }
497 } // namespace OHOS
498