1 /*
2 * Copyright (c) 2024 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 <gmock/gmock.h>
17 #include <gtest/gtest.h>
18 #include <securec.h>
19 #include <thread>
20
21 #include "bus_center_info_key.h"
22 #include "lnn_ctrl_lane.h"
23 #include "lnn_feature_capability.h"
24 #include "lnn_lane.h"
25 #include "lnn_lane_common.h"
26 #include "lnn_lane_deps_mock.h"
27 #include "lnn_lane_def.h"
28 #include "lnn_lane_interface.h"
29 #include "lnn_lane_link.h"
30 #include "lnn_lane_model.h"
31 #include "lnn_lane_select.h"
32 #include "lnn_select_rule.h"
33 #include "lnn_wifi_adpter_mock.h"
34 #include "message_handler.h"
35 #include "softbus_adapter_mem.h"
36 #include "softbus_adapter_thread.h"
37 #include "softbus_error_code.h"
38 #include "softbus_wifi_api_adapter.h"
39 #include "lnn_lane_reliability.h"
40 #include "lnn_lane_reliability.c"
41 #include "wifi_direct_error_code.h"
42
43 namespace OHOS {
44 using namespace testing::ext;
45 using namespace testing;
46
47 constexpr char NODE_NETWORK_ID[] = "111122223333abcdef";
48 constexpr char PEER_IP_HML[] = "172.30.0.1";
49 constexpr char PEER_MAC[] = "a1:b2:c3:d4:e5:f6";
50 constexpr char LOCAL_MAC[] = "a2:b2:c3:d4:e5:f6";
51 constexpr char PEER_UDID[] = "111122223333abcdef";
52 constexpr char LOCAL_UDID[] = "444455556666abcdef";
53 constexpr uint64_t LANE_ID_BASE = 1122334455667788;
54 constexpr uint32_t DEFAULT_SELECT_NUM = 4;
55 constexpr uint32_t DEFAULT_QOSINFO_MIN_BW = 10;
56 constexpr uint32_t DEFAULT_QOSINFO_MAX_LATENCY = 10000;
57 constexpr uint32_t DEFAULT_QOSINFO_MIN_LATENCY = 2500;
58 constexpr uint32_t DEFAULT_LANE_RESOURCE_LANE_REF = 0;
59 constexpr uint32_t LOW_BW = 384 * 1024;
60 constexpr uint32_t MID_BW = 30 * 1024 * 1024;
61 constexpr uint32_t HIGH_BW = 160 * 1024 * 1024;
62 constexpr uint32_t MESH_MAGIC_NUMBER = 0x5A5A5A5A;
63 constexpr uint32_t PORT_A = 22;
64 constexpr uint32_t PORT_B = 25;
65 constexpr uint32_t FD = 888;
66 constexpr uint32_t SLEEP_FOR_LOOP_COMPLETION_MS = 50;
67 constexpr uint32_t NET_CAP = 63;
68 constexpr uint32_t FREQUENCY_2G_FIRST = 2412;
69 constexpr uint32_t LOCAL_NUM = 8192;
70 constexpr uint32_t ROM_NUM = 8;
71 constexpr uint32_t ROM_NUM2 = 2;
72
73 static SoftBusCond g_cond = {0};
74 static SoftBusMutex g_lock = {0};
75
76 static void OnLaneAllocSuccess(uint32_t laneHandle, const LaneConnInfo *info);
77 static void OnLaneAllocFail(uint32_t laneHandle, int32_t errCode);
78 static void OnLaneFreeSuccess(uint32_t laneHandle);
79 static void OnLaneFreeFail(uint32_t laneHandle, int32_t errCode);
80
81 static int32_t g_errCode = 0;
82 static LaneAllocListener g_listener = {
83 .onLaneAllocSuccess = OnLaneAllocSuccess,
84 .onLaneAllocFail = OnLaneAllocFail,
85 .onLaneFreeSuccess = OnLaneFreeSuccess,
86 .onLaneFreeFail = OnLaneFreeFail,
87 };
88
OnLaneRequestSuccess(uint32_t laneId,const LaneConnInfo * info)89 static void OnLaneRequestSuccess(uint32_t laneId, const LaneConnInfo *info)
90 {
91 GTEST_LOG_(INFO) << "OnLaneRequestSuccess";
92 }
93
OnLaneRequestFail(uint32_t laneId,int32_t reason)94 static void OnLaneRequestFail(uint32_t laneId, int32_t reason)
95 {
96 GTEST_LOG_(INFO) << "OnLaneRequestFail";
97 }
98
99 static ILaneListener g_listener2 = {
100 .onLaneRequestSuccess = OnLaneRequestSuccess,
101 .onLaneRequestFail = OnLaneRequestFail,
102 };
103
104 static NodeInfo g_NodeInfo = {
105 .p2pInfo.p2pRole = 1,
106 .p2pInfo.p2pMac = "abc",
107 .p2pInfo.goMac = "abc",
108 };
109
110 class LNNLaneMockTest : public testing::Test {
111 public:
112 static void SetUpTestCase();
113 static void TearDownTestCase();
114 void SetUp();
115 void TearDown();
116 };
117
SetUpTestCase()118 void LNNLaneMockTest::SetUpTestCase()
119 {
120 int32_t ret = LnnInitLnnLooper();
121 EXPECT_TRUE(ret == SOFTBUS_OK);
122 ret = LooperInit();
123 NiceMock<LaneDepsInterfaceMock> mock;
124 EXPECT_CALL(mock, StartBaseClient).WillRepeatedly(LaneDepsInterfaceMock::ActionOfStartBaseClient);
125 ret = InitLane();
126 EXPECT_TRUE(ret == SOFTBUS_OK);
127 GTEST_LOG_(INFO) << "LNNLaneMockTest start";
128 }
129
TearDownTestCase()130 void LNNLaneMockTest::TearDownTestCase()
131 {
132 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
133 EXPECT_CALL(wifiMock, LnnDestroyP2p).WillRepeatedly(Return());
134 DeinitLane();
135 LooperDeinit();
136 LnnDeinitLnnLooper();
137 GTEST_LOG_(INFO) << "LNNLaneMockTest end";
138 }
139
SetUp()140 void LNNLaneMockTest::SetUp()
141 {
142 (void)SoftBusMutexInit(&g_lock, nullptr);
143 (void)SoftBusCondInit(&g_cond);
144 }
145
TearDown()146 void LNNLaneMockTest::TearDown()
147 {
148 (void)SoftBusCondDestroy(&g_cond);
149 (void)SoftBusCondDestroy(&g_lock);
150 }
151
CondSignal(void)152 static void CondSignal(void)
153 {
154 if (SoftBusMutexLock(&g_lock) != SOFTBUS_OK) {
155 return;
156 }
157 if (SoftBusCondSignal(&g_cond) != SOFTBUS_OK) {
158 (void)SoftBusMutexUnlock(&g_lock);
159 return;
160 }
161 (void)SoftBusMutexUnlock(&g_lock);
162 }
163
CondWait(void)164 static void CondWait(void)
165 {
166 if (SoftBusMutexLock(&g_lock) != SOFTBUS_OK) {
167 return;
168 }
169 if (SoftBusCondWait(&g_cond, &g_lock, nullptr) != SOFTBUS_OK) {
170 (void)SoftBusMutexUnlock(&g_lock);
171 return;
172 }
173 (void)SoftBusMutexUnlock(&g_lock);
174 }
175
OnLaneAllocSuccess(uint32_t laneHandle,const LaneConnInfo * info)176 static void OnLaneAllocSuccess(uint32_t laneHandle, const LaneConnInfo *info)
177 {
178 ASSERT_NE(info, nullptr) << "invalid info";
179 GTEST_LOG_(INFO) << "alloc lane successful, laneReqId=" << laneHandle << ", linkType=" << info->type;
180 const LnnLaneManager *laneManager = GetLaneManager();
181 int32_t ret = laneManager->lnnFreeLane(laneHandle);
182 EXPECT_TRUE(ret == SOFTBUS_OK);
183 CondSignal();
184 }
185
OnLaneAllocFail(uint32_t laneHandle,int32_t errCode)186 static void OnLaneAllocFail(uint32_t laneHandle, int32_t errCode)
187 {
188 GTEST_LOG_(INFO) << "alloc lane failed, laneReqId=" << laneHandle << ", errCode=" << errCode;
189 EXPECT_NE(errCode, SOFTBUS_OK);
190 g_errCode = errCode;
191 const LnnLaneManager *laneManager = GetLaneManager();
192 int32_t ret = laneManager->lnnFreeLane(laneHandle);
193 EXPECT_TRUE(ret == SOFTBUS_OK);
194 CondSignal();
195 }
196
OnLaneFreeSuccess(uint32_t laneHandle)197 static void OnLaneFreeSuccess(uint32_t laneHandle)
198 {
199 GTEST_LOG_(INFO) << "free lane success, laneReqId=" << laneHandle;
200 CondSignal();
201 }
202
OnLaneFreeFail(uint32_t laneHandle,int32_t errCode)203 static void OnLaneFreeFail(uint32_t laneHandle, int32_t errCode)
204 {
205 GTEST_LOG_(INFO) << "free lane failed, laneReqId=" << laneHandle << ", errCode=" << errCode;
206 CondSignal();
207 }
208
OnLaneLinkFail(uint32_t reqId,int32_t reason,LaneLinkType linkType)209 static void OnLaneLinkFail(uint32_t reqId, int32_t reason, LaneLinkType linkType)
210 {
211 (void)reqId;
212 (void)reason;
213 (void)linkType;
214 return;
215 }
216
OnLaneLinkSuccess(uint32_t reqId,LaneLinkType linkType,const LaneLinkInfo * linkInfo)217 static void OnLaneLinkSuccess(uint32_t reqId, LaneLinkType linkType, const LaneLinkInfo *linkInfo)
218 {
219 (void)reqId;
220 (void)linkType;
221 (void)linkInfo;
222 return;
223 }
224
OnLaneLinkSuccessForDetect(uint32_t reqId,LaneLinkType linkType,const LaneLinkInfo * linkInfo)225 static void OnLaneLinkSuccessForDetect(uint32_t reqId, LaneLinkType linkType, const LaneLinkInfo *linkInfo)
226 {
227 (void)reqId;
228 (void)linkInfo;
229 GTEST_LOG_(INFO) << "on laneLink success for detect";
230 EXPECT_EQ(linkType, LANE_WLAN_5G);
231 }
232
OnLaneLinkFailForDetect(uint32_t reqId,int32_t reason,LaneLinkType linkType)233 static void OnLaneLinkFailForDetect(uint32_t reqId, int32_t reason, LaneLinkType linkType)
234 {
235 (void)reqId;
236 (void)linkType;
237 GTEST_LOG_(INFO) << "on laneLink fail for detect";
238 EXPECT_EQ(reason, SOFTBUS_OK);
239 }
240
OnLaneAllocSuccessForHml(uint32_t laneHandle,const LaneConnInfo * info)241 static void OnLaneAllocSuccessForHml(uint32_t laneHandle, const LaneConnInfo *info)
242 {
243 (void)laneHandle;
244 ASSERT_NE(info, nullptr) << "invalid connInfo";
245 GTEST_LOG_(INFO) << "alloc lane successful, linkType=" << info->type;
246 EXPECT_EQ(info->type, LANE_HML);
247 CondSignal();
248 }
249
OnLaneAllocSuccessForP2p(uint32_t laneHandle,const LaneConnInfo * info)250 static void OnLaneAllocSuccessForP2p(uint32_t laneHandle, const LaneConnInfo *info)
251 {
252 (void)laneHandle;
253 ASSERT_NE(info, nullptr) << "invalid connInfo";
254 GTEST_LOG_(INFO) << "alloc lane successful, linkType=" << info->type;
255 EXPECT_EQ(info->type, LANE_P2P);
256 CondSignal();
257 }
258
OnLaneAllocSuccessForBr(uint32_t laneHandle,const LaneConnInfo * info)259 static void OnLaneAllocSuccessForBr(uint32_t laneHandle, const LaneConnInfo *info)
260 {
261 (void)laneHandle;
262 ASSERT_NE(info, nullptr) << "invalid connInfo";
263 GTEST_LOG_(INFO) << "alloc lane successful, linkType=" << info->type;
264 EXPECT_EQ(info->type, LANE_BR);
265 CondSignal();
266 }
267
OnLaneAllocSuccessForWlan5g(uint32_t laneHandle,const LaneConnInfo * info)268 static void OnLaneAllocSuccessForWlan5g(uint32_t laneHandle, const LaneConnInfo *info)
269 {
270 (void)laneHandle;
271 ASSERT_NE(info, nullptr) << "invalid connInfo";
272 GTEST_LOG_(INFO) << "alloc lane successful, linkType=" << info->type;
273 EXPECT_EQ(info->type, LANE_WLAN_5G);
274 CondSignal();
275 }
276
OnLaneAllocSuccessForBle(uint32_t laneHandle,const LaneConnInfo * info)277 static void OnLaneAllocSuccessForBle(uint32_t laneHandle, const LaneConnInfo *info)
278 {
279 (void)laneHandle;
280 ASSERT_NE(info, nullptr) << "invalid connInfo";
281 GTEST_LOG_(INFO) << "alloc lane successful, linkType=" << info->type;
282 EXPECT_EQ(info->type, LANE_BLE);
283 CondSignal();
284 }
285
OnLaneAllocFailNoExcept(uint32_t laneHandle,int32_t errCode)286 static void OnLaneAllocFailNoExcept(uint32_t laneHandle, int32_t errCode)
287 {
288 GTEST_LOG_(INFO) << "alloc lane failed, laneReqId=" << laneHandle;
289 EXPECT_EQ(errCode, SOFTBUS_LANE_SUCC_AFTER_CANCELED);
290 CondSignal();
291 }
292
OnLaneAllocFailNoExcept2(uint32_t laneHandle,int32_t errCode)293 static void OnLaneAllocFailNoExcept2(uint32_t laneHandle, int32_t errCode)
294 {
295 GTEST_LOG_(INFO) << "alloc lane failed, laneReqId=" << laneHandle;
296 EXPECT_EQ(errCode, SOFTBUS_LANE_GET_LEDGER_INFO_ERR);
297 CondSignal();
298 }
299
300 static LaneAllocListener g_listenerCbForHml = {
301 .onLaneAllocSuccess = OnLaneAllocSuccessForHml,
302 .onLaneAllocFail = OnLaneAllocFailNoExcept,
303 .onLaneFreeSuccess = OnLaneFreeSuccess,
304 .onLaneFreeFail = OnLaneFreeFail,
305 };
306
307 static LaneAllocListener g_listenerCbForP2p = {
308 .onLaneAllocSuccess = OnLaneAllocSuccessForP2p,
309 .onLaneAllocFail = OnLaneAllocFailNoExcept,
310 .onLaneFreeSuccess = OnLaneFreeSuccess,
311 .onLaneFreeFail = OnLaneFreeFail,
312 };
313
314 static LaneAllocListener g_listenerCbForP2p2 = {
315 .onLaneAllocSuccess = OnLaneAllocSuccessForP2p,
316 .onLaneAllocFail = OnLaneAllocFailNoExcept2,
317 .onLaneFreeSuccess = OnLaneFreeSuccess,
318 .onLaneFreeFail = OnLaneFreeFail,
319 };
320
321 static LaneAllocListener g_listenerCbForBr = {
322 .onLaneAllocSuccess = OnLaneAllocSuccessForBr,
323 .onLaneAllocFail = OnLaneAllocFailNoExcept,
324 .onLaneFreeSuccess = OnLaneFreeSuccess,
325 .onLaneFreeFail = OnLaneFreeFail,
326 };
327
328 static LaneAllocListener g_listenerCbForWlan5g = {
329 .onLaneAllocSuccess = OnLaneAllocSuccessForWlan5g,
330 .onLaneAllocFail = OnLaneAllocFailNoExcept,
331 .onLaneFreeSuccess = OnLaneFreeSuccess,
332 .onLaneFreeFail = OnLaneFreeFail,
333 };
334
335 static LaneAllocListener g_listenerCbForBle = {
336 .onLaneAllocSuccess = OnLaneAllocSuccessForBle,
337 .onLaneAllocFail = OnLaneAllocFailNoExcept,
338 .onLaneFreeSuccess = OnLaneFreeSuccess,
339 .onLaneFreeFail = OnLaneFreeFail,
340 };
341
AddLaneResourceForAllocTest(LaneLinkType linkType)342 static int32_t AddLaneResourceForAllocTest(LaneLinkType linkType)
343 {
344 LaneLinkInfo linkInfo = {};
345 linkInfo.type = linkType;
346 if (strncpy_s(linkInfo.linkInfo.p2p.connInfo.peerIp, IP_LEN, PEER_IP_HML, strlen(PEER_IP_HML)) != EOK) {
347 return SOFTBUS_STRCPY_ERR;
348 }
349 if (strncpy_s(linkInfo.peerUdid, UDID_BUF_LEN, PEER_UDID, strlen(PEER_UDID)) != EOK) {
350 return SOFTBUS_STRCPY_ERR;
351 }
352 return AddLaneResourceToPool(&linkInfo, LANE_ID_BASE, false);
353 }
354
CreateAllocInfoForAllocTest(LaneTransType transType,uint32_t minBW,uint32_t maxLaneLatency,uint32_t minLaneLatency,LaneAllocInfo * allocInfo)355 static void CreateAllocInfoForAllocTest(LaneTransType transType, uint32_t minBW, uint32_t maxLaneLatency,
356 uint32_t minLaneLatency, LaneAllocInfo *allocInfo)
357 {
358 ASSERT_NE(allocInfo, nullptr) << "invalid allocInfo";
359 allocInfo->type = LANE_TYPE_TRANS;
360 ASSERT_EQ(strncpy_s(allocInfo->networkId, NETWORK_ID_BUF_LEN,
361 NODE_NETWORK_ID, strlen(NODE_NETWORK_ID)), EOK);
362 allocInfo->transType = transType;
363 allocInfo->qosRequire.minBW = minBW;
364 allocInfo->qosRequire.maxLaneLatency = maxLaneLatency;
365 allocInfo->qosRequire.minLaneLatency = minLaneLatency;
366 }
367
PrejudgeAvailability(const char * remoteNetworkId,enum WifiDirectLinkType connectType)368 static int32_t PrejudgeAvailability(const char *remoteNetworkId, enum WifiDirectLinkType connectType)
369 {
370 (void)remoteNetworkId;
371 (void)connectType;
372 GTEST_LOG_(INFO) << "PrejudgeAvailability Enter";
373 return SOFTBUS_OK;
374 }
375
GetLocalAndRemoteMacByLocalIp(const char * localIp,char * localMac,size_t localMacSize,char * remoteMac,size_t remoteMacSize)376 static int32_t GetLocalAndRemoteMacByLocalIp(const char *localIp, char *localMac, size_t localMacSize,
377 char *remoteMac, size_t remoteMacSize)
378 {
379 (void)localIp;
380 (void)localMac;
381 (void)localMacSize;
382 (void)remoteMac;
383 (void)remoteMacSize;
384 return SOFTBUS_OK;
385 }
386
387 static struct WifiDirectManager g_manager = {
388 .prejudgeAvailability = PrejudgeAvailability,
389 .getLocalAndRemoteMacByLocalIp = GetLocalAndRemoteMacByLocalIp,
390 };
391 /*
392 * @tc.name: LANE_ALLOC_ErrTest_001
393 * @tc.desc: lane errcode test
394 * @tc.type: FUNC
395 * @tc.require:
396 */
397 HWTEST_F(LNNLaneMockTest, LANE_ALLOC_ERRTEST_001, TestSize.Level1)
398 {
399 const LnnLaneManager *laneManager = GetLaneManager();
400 LaneType laneType = LANE_TYPE_TRANS;
401 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
402 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
403
404 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
405 wifiMock.SetDefaultResult();
406 EXPECT_CALL(wifiMock, LnnConnectP2p(NotNull(), laneReqId, NotNull()))
407 .WillRepeatedly(LnnWifiAdpterInterfaceMock::ActionOfOnConnectP2pFail);
408 NiceMock<LaneDepsInterfaceMock> mock;
409 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
410 mock.SetDefaultResultForAlloc(63, 63, 0, 0);
411 EXPECT_CALL(mock, ConnOpenClientSocket).WillRepeatedly(Return(SOFTBUS_CONN_FAIL));
412 EXPECT_CALL(mock, DeleteNetworkResourceByLaneId).WillRepeatedly(Return());
413
414 LaneAllocInfo allocInfo = {};
415 CreateAllocInfoForAllocTest(LANE_T_MSG, DEFAULT_QOSINFO_MIN_BW + HIGH_BW, DEFAULT_QOSINFO_MAX_LATENCY,
416 DEFAULT_QOSINFO_MIN_LATENCY, &allocInfo);
417 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listener);
418 EXPECT_EQ(ret, SOFTBUS_OK);
419 std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_FOR_LOOP_COMPLETION_MS));
420 EXPECT_EQ(g_errCode, ERROR_WIFI_OFF);
421
422 (void)laneManager->lnnFreeLane(laneReqId);
423 }
424
425 /*
426 * @tc.name: LANE_ALLOC_Test_001
427 * @tc.desc: lane alloc by select default link for T_MSG (build wlan5g)
428 * @tc.type: FUNC
429 * @tc.require:
430 */
431 HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_001, TestSize.Level1)
432 {
433 const LnnLaneManager *laneManager = GetLaneManager();
434 LaneType laneType = LANE_TYPE_TRANS;
435 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
436 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
437
438 NiceMock<LaneDepsInterfaceMock> mock;
439 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
440 mock.SetDefaultResultForAlloc(1 << BIT_WIFI_5G, 1 << BIT_WIFI_5G, 0, 0);
441 EXPECT_CALL(mock, AddTrigger).WillRepeatedly(LaneDepsInterfaceMock::ActionOfAddTrigger);
442 char buf[] = "lanedetect";
443 EXPECT_CALL(mock, ConnSendSocketData).WillRepeatedly(Return(sizeof(buf)));
444 EXPECT_CALL(mock, DeleteNetworkResourceByLaneId).WillRepeatedly(Return());
445 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
446 wifiMock.SetDefaultResult();
447 SoftBusWifiLinkedInfo wlanInfo;
448 wlanInfo.connState = SOFTBUS_API_WIFI_CONNECTED;
449 EXPECT_CALL(wifiMock, SoftBusGetLinkedInfo)
450 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM1>(wlanInfo), Return(SOFTBUS_OK)));
451
452 LaneAllocInfo allocInfo = {};
453 CreateAllocInfoForAllocTest(LANE_T_MSG, 0, 0, 0, &allocInfo);
454 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForWlan5g);
455 EXPECT_EQ(ret, SOFTBUS_OK);
456 CondWait();
457 ret = laneManager->lnnFreeLane(laneReqId);
458 EXPECT_EQ(ret, SOFTBUS_OK);
459 CondWait();
460 }
461
462 /*
463 * @tc.name: LANE_ALLOC_Test_002
464 * @tc.desc: lane alloc by select default link for T_BYTE (not enable wlan and br, build ble)
465 * @tc.type: FUNC
466 * @tc.require:
467 */
468 HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_002, TestSize.Level1)
469 {
470 const LnnLaneManager *laneManager = GetLaneManager();
471 LaneType laneType = LANE_TYPE_TRANS;
472 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
473 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
474
475 NiceMock<LaneDepsInterfaceMock> mock;
476 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
477 mock.SetDefaultResultForAlloc(1 << BIT_BLE, 1 << BIT_BLE, 0, 0);
478 EXPECT_CALL(mock, DeleteNetworkResourceByLaneId).WillRepeatedly(Return());
479 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
480 wifiMock.SetDefaultResult();
481 LaneAllocInfo allocInfo = {};
482 ASSERT_EQ(strncpy_s(allocInfo.extendInfo.peerBleMac, MAX_MAC_LEN,
483 PEER_MAC, strlen(PEER_MAC)), EOK);
484 CreateAllocInfoForAllocTest(LANE_T_BYTE, 0, 0, 0, &allocInfo);
485 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForBle);
486 EXPECT_EQ(ret, SOFTBUS_OK);
487 CondWait();
488 ret = laneManager->lnnFreeLane(laneReqId);
489 EXPECT_EQ(ret, SOFTBUS_OK);
490 CondWait();
491 }
492
493 /*
494 * @tc.name: LANE_ALLOC_Test_003
495 * @tc.desc: lane alloc by select default link for T_FILE (not enable wlan and hml, build p2p)
496 * @tc.type: FUNC
497 * @tc.require:
498 */
499 HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_003, TestSize.Level1)
500 {
501 const LnnLaneManager *laneManager = GetLaneManager();
502 LaneType laneType = LANE_TYPE_TRANS;
503 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
504 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
505
506 NiceMock<LaneDepsInterfaceMock> mock;
507 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
508 mock.SetDefaultResultForAlloc(1 << BIT_WIFI_P2P, 1 << BIT_WIFI_P2P, 0, 0);
509 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
510 wifiMock.SetDefaultResult();
511 EXPECT_CALL(wifiMock, LnnConnectP2p(NotNull(), laneReqId, NotNull()))
512 .WillRepeatedly(LnnWifiAdpterInterfaceMock::ActionOfLnnConnectP2p);
513
514 LaneAllocInfo allocInfo = {};
515 CreateAllocInfoForAllocTest(LANE_T_FILE, 0, 0, 0, &allocInfo);
516 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForP2p);
517 EXPECT_EQ(ret, SOFTBUS_OK);
518 CondWait();
519
520 ret = laneManager->lnnFreeLane(laneReqId);
521 EXPECT_EQ(ret, SOFTBUS_OK);
522 }
523
524 /*
525 * @tc.name: LANE_ALLOC_Test_004
526 * @tc.desc: lane alloc by select default link for T_RAW_STREAM (not enable wlan, build p2p)
527 * @tc.type: FUNC
528 * @tc.require:
529 */
530 HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_004, TestSize.Level1)
531 {
532 const LnnLaneManager *laneManager = GetLaneManager();
533 LaneType laneType = LANE_TYPE_TRANS;
534 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
535 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
536
537 NiceMock<LaneDepsInterfaceMock> mock;
538 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
539 mock.SetDefaultResultForAlloc(1 << BIT_WIFI_P2P, 1 << BIT_WIFI_P2P, 0, 0);
540 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
541 wifiMock.SetDefaultResult();
542 EXPECT_CALL(wifiMock, LnnConnectP2p(NotNull(), laneReqId, NotNull()))
543 .WillRepeatedly(LnnWifiAdpterInterfaceMock::ActionOfLnnConnectP2p);
544
545 LaneAllocInfo allocInfo = {};
546 CreateAllocInfoForAllocTest(LANE_T_RAW_STREAM, 0, 0, 0, &allocInfo);
547 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForP2p);
548 EXPECT_EQ(ret, SOFTBUS_OK);
549 CondWait();
550 ret = laneManager->lnnFreeLane(laneReqId);
551 EXPECT_EQ(ret, SOFTBUS_OK);
552 }
553
554 /*
555 * @tc.name: LANE_ALLOC_Test_005
556 * @tc.desc: lane alloc by mesh link (not enable wlan, build br)
557 * @tc.type: FUNC
558 * @tc.require:
559 */
560 HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_005, TestSize.Level1)
561 {
562 const LnnLaneManager *laneManager = GetLaneManager();
563 LaneType laneType = LANE_TYPE_TRANS;
564 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
565 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
566
567 NiceMock<LaneDepsInterfaceMock> mock;
568 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
569 mock.SetDefaultResultForAlloc(1 << BIT_BR, 1 << BIT_BR, 0, 0);
570 EXPECT_CALL(mock, DeleteNetworkResourceByLaneId).WillRepeatedly(Return());
571 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
572 wifiMock.SetDefaultResult();
573
574 LaneAllocInfo allocInfo = {};
575 CreateAllocInfoForAllocTest(LANE_T_RAW_STREAM, MESH_MAGIC_NUMBER, 0, 0, &allocInfo);
576 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForBr);
577 EXPECT_EQ(ret, SOFTBUS_OK);
578 CondWait();
579 ret = laneManager->lnnFreeLane(laneReqId);
580 EXPECT_EQ(ret, SOFTBUS_OK);
581 CondWait();
582 }
583
584 /*
585 * @tc.name: LANE_ALLOC_Test_006
586 * @tc.desc: lane alloc by RTT link (not enable hml, build p2p)
587 * @tc.type: FUNC
588 * @tc.require:
589 */
590 HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_006, TestSize.Level1)
591 {
592 const LnnLaneManager *laneManager = GetLaneManager();
593 LaneType laneType = LANE_TYPE_TRANS;
594 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
595 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
596
597 NiceMock<LaneDepsInterfaceMock> mock;
598 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
599 mock.SetDefaultResultForAlloc(1 << BIT_WIFI_P2P, 1 << BIT_WIFI_P2P, 0, 0);
600 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
601 wifiMock.SetDefaultResult();
602 EXPECT_CALL(wifiMock, LnnConnectP2p(NotNull(), laneReqId, NotNull()))
603 .WillRepeatedly(LnnWifiAdpterInterfaceMock::ActionOfLnnConnectP2p);
604
605 LaneAllocInfo allocInfo = {};
606 allocInfo.qosRequire.rttLevel = LANE_RTT_LEVEL_LOW;
607 CreateAllocInfoForAllocTest(LANE_T_RAW_STREAM, DEFAULT_QOSINFO_MIN_BW, 0, 0, &allocInfo);
608 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForP2p);
609 EXPECT_EQ(ret, SOFTBUS_OK);
610 CondWait();
611 ret = laneManager->lnnFreeLane(laneReqId);
612 EXPECT_EQ(ret, SOFTBUS_OK);
613 }
614
615 /*
616 * @tc.name: LANE_ALLOC_Test_007
617 * @tc.desc: lane alloc by qos require (HIGH_BW, build hml)
618 * @tc.type: FUNC
619 * @tc.require:
620 */
621 HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_007, TestSize.Level1)
622 {
623 const LnnLaneManager *laneManager = GetLaneManager();
624 LaneType laneType = LANE_TYPE_TRANS;
625 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
626 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
627
628 NiceMock<LaneDepsInterfaceMock> mock;
629 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
630 mock.SetDefaultResultForAlloc(1 << BIT_WIFI_P2P, 1 << BIT_WIFI_P2P, 1 << BIT_WIFI_DIRECT_TLV_NEGOTIATION,
631 1 << BIT_WIFI_DIRECT_TLV_NEGOTIATION);
632 EXPECT_CALL(mock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
633 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
634 wifiMock.SetDefaultResult();
635 EXPECT_CALL(wifiMock, LnnConnectP2p(NotNull(), laneReqId, NotNull()))
636 .WillRepeatedly(LnnWifiAdpterInterfaceMock::ActionOfLnnConnectP2p);
637
638 LaneAllocInfo allocInfo = {};
639 CreateAllocInfoForAllocTest(LANE_T_MSG, DEFAULT_QOSINFO_MIN_BW + HIGH_BW, DEFAULT_QOSINFO_MAX_LATENCY,
640 DEFAULT_QOSINFO_MIN_LATENCY, &allocInfo);
641 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForHml);
642 EXPECT_EQ(ret, SOFTBUS_OK);
643 CondWait();
644 ret = laneManager->lnnFreeLane(laneReqId);
645 EXPECT_EQ(ret, SOFTBUS_OK);
646 }
647
648 /*
649 * @tc.name: LANE_ALLOC_Test_008
650 * @tc.desc: lane alloc by qos require (MID_HIGH_BW, not enable hml, build wlan5g)
651 * @tc.type: FUNC
652 * @tc.require:
653 */
654 HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_008, TestSize.Level1)
655 {
656 const LnnLaneManager *laneManager = GetLaneManager();
657 LaneType laneType = LANE_TYPE_TRANS;
658 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
659 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
660
661 NiceMock<LaneDepsInterfaceMock> mock;
662 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
663 mock.SetDefaultResultForAlloc(1 << BIT_WIFI_5G, 1 << BIT_WIFI_5G, 0, 0);
664 EXPECT_CALL(mock, AddTrigger).WillRepeatedly(LaneDepsInterfaceMock::ActionOfAddTrigger);
665 char buf[] = "lanedetect";
666 EXPECT_CALL(mock, ConnSendSocketData).WillRepeatedly(Return(sizeof(buf)));
667 EXPECT_CALL(mock, DeleteNetworkResourceByLaneId).WillRepeatedly(Return());
668 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
669 wifiMock.SetDefaultResult();
670 SoftBusWifiLinkedInfo wlanInfo;
671 wlanInfo.band = 0;
672 wlanInfo.connState = SOFTBUS_API_WIFI_CONNECTED;
673 EXPECT_CALL(wifiMock, SoftBusGetLinkedInfo)
674 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM1>(wlanInfo), Return(SOFTBUS_OK)));
675
676 LaneAllocInfo allocInfo = {};
677 CreateAllocInfoForAllocTest(LANE_T_MSG, DEFAULT_QOSINFO_MIN_BW + MID_BW, DEFAULT_QOSINFO_MAX_LATENCY,
678 DEFAULT_QOSINFO_MIN_LATENCY, &allocInfo);
679 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForWlan5g);
680 EXPECT_EQ(ret, SOFTBUS_OK);
681 CondWait();
682 ret = laneManager->lnnFreeLane(laneReqId);
683 EXPECT_EQ(ret, SOFTBUS_OK);
684 CondWait();
685 }
686
687 /*
688 * @tc.name: LANE_ALLOC_Test_009
689 * @tc.desc: lane alloc by qos require (MID_LOW_BW, not enable wlan5g and hml, build wlan24g)
690 * @tc.type: FUNC
691 * @tc.require:
692 */
693 HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_009, TestSize.Level1)
694 {
695 const LnnLaneManager *laneManager = GetLaneManager();
696 LaneType laneType = LANE_TYPE_TRANS;
697 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
698 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
699
700 NiceMock<LaneDepsInterfaceMock> mock;
701 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
702 mock.SetDefaultResultForAlloc(1 << BIT_WIFI_5G, 1 << BIT_WIFI_5G, 0, 0);
703 EXPECT_CALL(mock, AddTrigger).WillRepeatedly(LaneDepsInterfaceMock::ActionOfAddTrigger);
704 char buf[] = "lanedetect";
705 EXPECT_CALL(mock, ConnSendSocketData).WillRepeatedly(Return(sizeof(buf)));
706 EXPECT_CALL(mock, DeleteNetworkResourceByLaneId).WillRepeatedly(Return());
707 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
708 wifiMock.SetDefaultResult();
709 SoftBusWifiLinkedInfo wlanInfo;
710 wlanInfo.band = 1;
711 wlanInfo.connState = SOFTBUS_API_WIFI_CONNECTED;
712 EXPECT_CALL(wifiMock, SoftBusGetLinkedInfo)
713 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM1>(wlanInfo), Return(SOFTBUS_OK)));
714
715 LaneAllocInfo allocInfo = {};
716 CreateAllocInfoForAllocTest(LANE_T_MSG, DEFAULT_QOSINFO_MIN_BW + LOW_BW, DEFAULT_QOSINFO_MAX_LATENCY,
717 DEFAULT_QOSINFO_MIN_LATENCY, &allocInfo);
718 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForWlan5g);
719 EXPECT_EQ(ret, SOFTBUS_OK);
720 CondWait();
721 ret = laneManager->lnnFreeLane(laneReqId);
722 EXPECT_EQ(ret, SOFTBUS_OK);
723 CondWait();
724 }
725
726 /*
727 * @tc.name: LANE_ALLOC_Test_010
728 * @tc.desc: lane alloc by qos require (LOW_BW, not enable wlan5g\hml\br\p2p\coc_direct, build ble)
729 * @tc.type: FUNC
730 * @tc.require:
731 */
732 HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_010, TestSize.Level1)
733 {
734 const LnnLaneManager *laneManager = GetLaneManager();
735 LaneType laneType = LANE_TYPE_TRANS;
736 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
737 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
738
739 NiceMock<LaneDepsInterfaceMock> mock;
740 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
741 mock.SetDefaultResultForAlloc(1 << BIT_BLE, 1 << BIT_BLE, 0, 0);
742 EXPECT_CALL(mock, DeleteNetworkResourceByLaneId).WillRepeatedly(Return());
743 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
744 wifiMock.SetDefaultResult();
745
746 LaneAllocInfo allocInfo = {};
747 ASSERT_EQ(strncpy_s(allocInfo.extendInfo.peerBleMac, MAX_MAC_LEN,
748 PEER_MAC, strlen(PEER_MAC)), EOK);
749 CreateAllocInfoForAllocTest(LANE_T_MSG, LOW_BW - DEFAULT_QOSINFO_MIN_BW, DEFAULT_QOSINFO_MAX_LATENCY,
750 DEFAULT_QOSINFO_MIN_LATENCY, &allocInfo);
751 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForBle);
752 EXPECT_EQ(ret, SOFTBUS_OK);
753 CondWait();
754 ret = laneManager->lnnFreeLane(laneReqId);
755 EXPECT_EQ(ret, SOFTBUS_OK);
756 CondWait();
757 }
758
759 /*
760 * @tc.name: LANE_ALLOC_Test_011
761 * @tc.desc: lane alloc for exception deal before select link
762 * @tc.type: FAILUE
763 * @tc.require:
764 */
765 HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_011, TestSize.Level1)
766 {
767 const LnnLaneManager *laneManager = GetLaneManager();
768 LaneType laneType = LANE_TYPE_TRANS;
769 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
770 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
771
772 NiceMock<LaneDepsInterfaceMock> mock;
773 EXPECT_CALL(mock, LnnGetOnlineStateById).WillRepeatedly(Return(false));
774
775 LaneAllocInfo allocInfo = {};
776 int32_t ret = laneManager->lnnAllocLane(laneReqId, nullptr, &g_listenerCbForP2p);
777 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
778
779 ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, nullptr);
780 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
781
782 allocInfo.type = LANE_TYPE_BUTT;
783 ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForP2p);
784 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
785
786 allocInfo.type = (LaneType)-1;
787 ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForP2p);
788 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
789
790 ret = laneManager->lnnAllocLane(INVALID_LANE_REQ_ID, &allocInfo, &g_listenerCbForP2p);
791 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
792
793 allocInfo.type = LANE_TYPE_HDLC;
794 ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForP2p);
795 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
796
797 allocInfo.type = laneType;
798 ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForP2p);
799 EXPECT_EQ(ret, SOFTBUS_NETWORK_NODE_OFFLINE);
800
801 ret = laneManager->lnnFreeLane(laneReqId);
802 EXPECT_EQ(ret, SOFTBUS_LANE_NOT_FOUND);
803 }
804
805 /*
806 * @tc.name: LANE_RE_ALLOC_Test_001
807 * @tc.desc: lane re alloc for invalid param
808 * @tc.type: FUNC
809 * @tc.require:
810 */
811 HWTEST_F(LNNLaneMockTest, LANE_RE_ALLOC_Test_001, TestSize.Level1)
812 {
813 const LnnLaneManager *laneManager = GetLaneManager();
814 LaneType laneType = LANE_TYPE_TRANS;
815 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
816 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
817
818 int32_t ret = laneManager->lnnReAllocLane(laneReqId, LANE_ID_BASE, nullptr, &g_listenerCbForP2p);
819 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
820
821 LaneAllocInfo allocInfo;
822 ASSERT_EQ(memset_s(&allocInfo, sizeof(LaneAllocInfo), 0, sizeof(LaneAllocInfo)), EOK);
823 allocInfo.type = LANE_TYPE_BUTT;
824
825 ret = laneManager->lnnReAllocLane(laneReqId, LANE_ID_BASE, &allocInfo, nullptr);
826 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
827
828 ret = laneManager->lnnReAllocLane(laneReqId, LANE_ID_BASE, &allocInfo, &g_listenerCbForP2p);
829 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
830
831 ret = laneManager->lnnReAllocLane(INVALID_LANE_REQ_ID, LANE_ID_BASE, &allocInfo, &g_listenerCbForP2p);
832 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
833
834 ret = laneManager->lnnReAllocLane(laneReqId, INVALID_LANE_ID, &allocInfo, &g_listenerCbForP2p);
835 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
836
837 allocInfo.type = LANE_TYPE_HDLC;
838 ret = laneManager->lnnReAllocLane(laneReqId, INVALID_LANE_ID, &allocInfo, &g_listenerCbForP2p);
839 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
840 }
841
842 /*
843 * @tc.name: LANE_RE_ALLOC_Test_002
844 * @tc.desc: lane re alloc for MSG HIGH_BW
845 * @tc.type: FUNC
846 * @tc.require:
847 */
848 HWTEST_F(LNNLaneMockTest, LANE_RE_ALLOC_Test_002, TestSize.Level1)
849 {
850 const LnnLaneManager *laneManager = GetLaneManager();
851 LaneType laneType = LANE_TYPE_TRANS;
852 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
853 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
854
855 NiceMock<LaneDepsInterfaceMock> mock;
856 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
857 mock.SetDefaultResultForAlloc(63, 63, 8, 8);
858 EXPECT_CALL(mock, DeleteNetworkResourceByLaneId).WillRepeatedly(Return());
859 EXPECT_CALL(mock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
860 int32_t ret = AddLaneResourceForAllocTest(LANE_HML);
861 EXPECT_EQ(ret, SOFTBUS_OK);
862
863 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
864 wifiMock.SetDefaultResult();
865 EXPECT_CALL(wifiMock, LnnConnectP2p(NotNull(), laneReqId, NotNull()))
866 .WillRepeatedly(LnnWifiAdpterInterfaceMock::ActionOfLnnConnectP2p);
867
868 LaneAllocInfo allocInfo;
869 ASSERT_EQ(memset_s(&allocInfo, sizeof(LaneAllocInfo), 0, sizeof(LaneAllocInfo)), EOK);
870 CreateAllocInfoForAllocTest(LANE_T_MSG, DEFAULT_QOSINFO_MIN_BW + HIGH_BW, DEFAULT_QOSINFO_MAX_LATENCY,
871 DEFAULT_QOSINFO_MIN_LATENCY, &allocInfo);
872 ret = laneManager->lnnReAllocLane(laneReqId, LANE_ID_BASE, &allocInfo, &g_listenerCbForP2p);
873 EXPECT_EQ(ret, SOFTBUS_OK);
874 CondWait();
875 ret = DelLaneResourceByLaneId(LANE_ID_BASE, false);
876 EXPECT_EQ(ret, SOFTBUS_OK);
877 ret = laneManager->lnnFreeLane(laneReqId);
878 EXPECT_TRUE(ret == SOFTBUS_OK);
879 }
880
881 /*
882 * @tc.name: LANE_RE_ALLOC_Test_003
883 * @tc.desc: lane re alloc for MSG MID_HIGH_BW
884 * @tc.type: FUNC
885 * @tc.require:
886 */
887 HWTEST_F(LNNLaneMockTest, LANE_RE_ALLOC_Test_003, TestSize.Level1)
888 {
889 const LnnLaneManager *laneManager = GetLaneManager();
890 LaneType laneType = LANE_TYPE_TRANS;
891 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
892 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
893
894 NiceMock<LaneDepsInterfaceMock> mock;
895 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
896 mock.SetDefaultResultForAlloc(63, 63, 8, 8);
897 EXPECT_CALL(mock, AddTrigger).WillRepeatedly(LaneDepsInterfaceMock::ActionOfAddTrigger);
898 char buf[] = "lanedetect";
899 EXPECT_CALL(mock, ConnSendSocketData).WillRepeatedly(Return(sizeof(buf)));
900 EXPECT_CALL(mock, DeleteNetworkResourceByLaneId).WillRepeatedly(Return());
901 EXPECT_CALL(mock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
902
903 int32_t ret = AddLaneResourceForAllocTest(LANE_HML);
904 EXPECT_EQ(ret, SOFTBUS_OK);
905
906 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
907 wifiMock.SetDefaultResult();
908 SoftBusWifiLinkedInfo wlanInfo;
909 wlanInfo.band = 0;
910 wlanInfo.connState = SOFTBUS_API_WIFI_CONNECTED;
911 EXPECT_CALL(wifiMock, SoftBusGetLinkedInfo)
912 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM1>(wlanInfo), Return(SOFTBUS_OK)));
913
914 LaneAllocInfo allocInfo;
915 ASSERT_EQ(memset_s(&allocInfo, sizeof(LaneAllocInfo), 0, sizeof(LaneAllocInfo)), EOK);
916 CreateAllocInfoForAllocTest(LANE_T_MSG, DEFAULT_QOSINFO_MIN_BW + MID_BW, DEFAULT_QOSINFO_MAX_LATENCY,
917 DEFAULT_QOSINFO_MIN_LATENCY, &allocInfo);
918 ret = laneManager->lnnReAllocLane(laneReqId, LANE_ID_BASE, &allocInfo, &g_listenerCbForWlan5g);
919 EXPECT_EQ(ret, SOFTBUS_OK);
920 CondWait();
921 ret = DelLaneResourceByLaneId(LANE_ID_BASE, false);
922 EXPECT_EQ(ret, SOFTBUS_OK);
923 ret = laneManager->lnnFreeLane(laneReqId);
924 EXPECT_TRUE(ret == SOFTBUS_OK);
925 CondWait();
926 }
927
928 /*
929 * @tc.name: LANE_RE_ALLOC_Test_004
930 * @tc.desc: lane re alloc for MSG MID_LOW_BW
931 * @tc.type: FUNC
932 * @tc.require:
933 */
934 HWTEST_F(LNNLaneMockTest, LANE_RE_ALLOC_Test_004, TestSize.Level1)
935 {
936 const LnnLaneManager *laneManager = GetLaneManager();
937 LaneType laneType = LANE_TYPE_TRANS;
938 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
939 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
940
941 NiceMock<LaneDepsInterfaceMock> mock;
942 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
943 mock.SetDefaultResultForAlloc(63, 63, 8, 8);
944 EXPECT_CALL(mock, DeleteNetworkResourceByLaneId).WillRepeatedly(Return());
945 EXPECT_CALL(mock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
946 int32_t ret = AddLaneResourceForAllocTest(LANE_WLAN_5G);
947 EXPECT_EQ(ret, SOFTBUS_OK);
948
949 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
950 wifiMock.SetDefaultResult();
951 EXPECT_CALL(wifiMock, LnnConnectP2p(NotNull(), laneReqId, NotNull()))
952 .WillRepeatedly(LnnWifiAdpterInterfaceMock::ActionOfLnnConnectP2p);
953
954 LaneAllocInfo allocInfo;
955 ASSERT_EQ(memset_s(&allocInfo, sizeof(LaneAllocInfo), 0, sizeof(LaneAllocInfo)), EOK);
956 CreateAllocInfoForAllocTest(LANE_T_MSG, DEFAULT_QOSINFO_MIN_BW + LOW_BW, DEFAULT_QOSINFO_MAX_LATENCY,
957 DEFAULT_QOSINFO_MIN_LATENCY, &allocInfo);
958 ret = laneManager->lnnReAllocLane(laneReqId, LANE_ID_BASE, &allocInfo, &g_listenerCbForHml);
959 EXPECT_EQ(ret, SOFTBUS_OK);
960 CondWait();
961 ret = DelLaneResourceByLaneId(LANE_ID_BASE, false);
962 EXPECT_EQ(ret, SOFTBUS_OK);
963 ret = laneManager->lnnFreeLane(laneReqId);
964 EXPECT_TRUE(ret == SOFTBUS_OK);
965 }
966
967 /*
968 * @tc.name: LANE_RE_ALLOC_Test_005
969 * @tc.desc: lane re alloc for MSG LOW_BW
970 * @tc.type: FUNC
971 * @tc.require:
972 */
973 HWTEST_F(LNNLaneMockTest, LANE_RE_ALLOC_Test_005, TestSize.Level1)
974 {
975 const LnnLaneManager *laneManager = GetLaneManager();
976 LaneType laneType = LANE_TYPE_TRANS;
977 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
978 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
979
980 NiceMock<LaneDepsInterfaceMock> mock;
981 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
982 mock.SetDefaultResultForAlloc(15, 15, 8, 8);
983 EXPECT_CALL(mock, DeleteNetworkResourceByLaneId).WillRepeatedly(Return());
984 EXPECT_CALL(mock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
985 int32_t ret = AddLaneResourceForAllocTest(LANE_HML);
986 EXPECT_EQ(ret, SOFTBUS_OK);
987
988 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
989 wifiMock.SetDefaultResult();
990
991 LaneAllocInfo allocInfo;
992 ASSERT_EQ(memset_s(&allocInfo, sizeof(LaneAllocInfo), 0, sizeof(LaneAllocInfo)), EOK);
993 CreateAllocInfoForAllocTest(LANE_T_MSG, LOW_BW - DEFAULT_QOSINFO_MIN_BW, DEFAULT_QOSINFO_MAX_LATENCY,
994 DEFAULT_QOSINFO_MIN_LATENCY, &allocInfo);
995 ret = laneManager->lnnReAllocLane(laneReqId, LANE_ID_BASE, &allocInfo, &g_listenerCbForBr);
996 EXPECT_EQ(ret, SOFTBUS_OK);
997 CondWait();
998 ret = DelLaneResourceByLaneId(LANE_ID_BASE, false);
999 EXPECT_EQ(ret, SOFTBUS_OK);
1000 ret = laneManager->lnnFreeLane(laneReqId);
1001 EXPECT_TRUE(ret == SOFTBUS_OK);
1002 CondWait();
1003 }
1004
1005 /*
1006 * @tc.name: LANE_CANCEL_Test_001
1007 * @tc.desc: lane cancel after notify
1008 * @tc.type: FUNC
1009 * @tc.require:
1010 */
1011 HWTEST_F(LNNLaneMockTest, LANE_CANCEL_Test_001, TestSize.Level1)
1012 {
1013 const LnnLaneManager *laneManager = GetLaneManager();
1014 LaneType laneType = LANE_TYPE_TRANS;
1015 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
1016 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
1017
1018 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1019 wifiMock.SetDefaultResult();
1020 EXPECT_CALL(wifiMock, LnnConnectP2p(NotNull(), laneReqId, NotNull()))
1021 .WillRepeatedly(LnnWifiAdpterInterfaceMock::ActionOfLnnConnectP2p);
1022 EXPECT_CALL(wifiMock, LnnCancelWifiDirect).WillRepeatedly(Return());
1023 NiceMock<LaneDepsInterfaceMock> mock;
1024 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
1025 mock.SetDefaultResultForAlloc(63, 63, 0, 0);
1026
1027 LaneAllocInfo allocInfo;
1028 ASSERT_EQ(memset_s(&allocInfo, sizeof(LaneAllocInfo), 0, sizeof(LaneAllocInfo)), EOK);
1029 CreateAllocInfoForAllocTest(LANE_T_MSG, DEFAULT_QOSINFO_MIN_BW + HIGH_BW, DEFAULT_QOSINFO_MAX_LATENCY,
1030 DEFAULT_QOSINFO_MIN_LATENCY, &allocInfo);
1031 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForP2p);
1032 EXPECT_EQ(ret, SOFTBUS_OK);
1033 CondWait();
1034 ret = laneManager->lnnCancelLane(laneReqId);
1035 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1036 ret = laneManager->lnnFreeLane(laneReqId);
1037 EXPECT_TRUE(ret == SOFTBUS_OK);
1038 }
1039
1040 /*
1041 * @tc.name: LANE_CANCEL_Test_002
1042 * @tc.desc: lane cancel before notify
1043 * @tc.type: FUNC
1044 * @tc.require:
1045 */
1046 HWTEST_F(LNNLaneMockTest, LANE_CANCEL_Test_002, TestSize.Level1)
1047 {
1048 const LnnLaneManager *laneManager = GetLaneManager();
1049 LaneType laneType = LANE_TYPE_TRANS;
1050 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
1051 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
1052
1053 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1054 LnnWifiAdpterInterfaceMock::delayNotifyLinkSuccess = true;
1055 wifiMock.SetDefaultResult();
1056 EXPECT_CALL(wifiMock, LnnConnectP2p(NotNull(), laneReqId, NotNull()))
1057 .WillRepeatedly(LnnWifiAdpterInterfaceMock::ActionOfLnnConnectP2p);
1058 EXPECT_CALL(wifiMock, LnnCancelWifiDirect).WillRepeatedly(Return());
1059 NiceMock<LaneDepsInterfaceMock> mock;
1060 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
1061 mock.SetDefaultResultForAlloc(63, 63, 0, 0);
1062
1063 LaneAllocInfo allocInfo;
1064 ASSERT_EQ(memset_s(&allocInfo, sizeof(LaneAllocInfo), 0, sizeof(LaneAllocInfo)), EOK);
1065 CreateAllocInfoForAllocTest(LANE_T_MSG, DEFAULT_QOSINFO_MIN_BW + HIGH_BW, DEFAULT_QOSINFO_MAX_LATENCY,
1066 DEFAULT_QOSINFO_MIN_LATENCY, &allocInfo);
1067 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForP2p);
1068 EXPECT_EQ(ret, SOFTBUS_OK);
1069 ret = laneManager->lnnCancelLane(laneReqId);
1070 EXPECT_EQ(ret, SOFTBUS_OK);
1071 LnnWifiAdpterInterfaceMock::delayNotifyLinkSuccess = false;
1072 std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_FOR_LOOP_COMPLETION_MS));
1073 }
1074
1075 /*
1076 * @tc.name: LANE_CANCEL_Test_003
1077 * @tc.desc: lane cancel after free
1078 * @tc.type: FUNC
1079 * @tc.require:
1080 */
1081 HWTEST_F(LNNLaneMockTest, LANE_CANCEL_Test_003, TestSize.Level1)
1082 {
1083 const LnnLaneManager *laneManager = GetLaneManager();
1084 LaneType laneType = LANE_TYPE_TRANS;
1085 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
1086 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
1087
1088 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1089 wifiMock.SetDefaultResult();
1090 EXPECT_CALL(wifiMock, LnnConnectP2p(NotNull(), laneReqId, NotNull()))
1091 .WillRepeatedly(LnnWifiAdpterInterfaceMock::ActionOfLnnConnectP2p);
1092 EXPECT_CALL(wifiMock, LnnCancelWifiDirect).WillRepeatedly(Return());
1093 NiceMock<LaneDepsInterfaceMock> mock;
1094 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
1095 mock.SetDefaultResultForAlloc(63, 63, 0, 0);
1096
1097 LaneAllocInfo allocInfo;
1098 ASSERT_EQ(memset_s(&allocInfo, sizeof(LaneAllocInfo), 0, sizeof(LaneAllocInfo)), EOK);
1099 CreateAllocInfoForAllocTest(LANE_T_MSG, DEFAULT_QOSINFO_MIN_BW + HIGH_BW, DEFAULT_QOSINFO_MAX_LATENCY,
1100 DEFAULT_QOSINFO_MIN_LATENCY, &allocInfo);
1101 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForP2p);
1102 EXPECT_EQ(ret, SOFTBUS_OK);
1103 CondWait();
1104 ret = laneManager->lnnFreeLane(laneReqId);
1105 EXPECT_TRUE(ret == SOFTBUS_OK);
1106 std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_FOR_LOOP_COMPLETION_MS));
1107 ret = laneManager->lnnCancelLane(laneReqId);
1108 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1109 }
1110
1111 /*
1112 * @tc.name: LANE_FREE_001
1113 * @tc.desc: lane free
1114 * @tc.type: FUNC
1115 * @tc.require:
1116 */
1117 HWTEST_F(LNNLaneMockTest, LANE_FREE_001, TestSize.Level1)
1118 {
1119 const LnnLaneManager *laneManager = GetLaneManager();
1120 LaneType laneType = LANE_TYPE_BUTT;
1121 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
1122 int32_t ret = laneManager->lnnFreeLane(laneReqId);
1123 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1124
1125 laneType = LANE_TYPE_TRANS;
1126 laneReqId = laneManager->lnnGetLaneHandle(laneType);
1127 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
1128 ret = laneManager->lnnFreeLane(laneReqId);
1129 EXPECT_EQ(ret, SOFTBUS_LANE_NOT_FOUND);
1130 ret = laneManager->lnnFreeLane(laneReqId);
1131 EXPECT_EQ(ret, SOFTBUS_LANE_NOT_FOUND);
1132 }
1133
1134 /*
1135 * @tc.name: LANE_INFO_001
1136 * @tc.desc: LaneInfoProcess BR
1137 * @tc.type: FUNC
1138 * @tc.require:
1139 */
1140 HWTEST_F(LNNLaneMockTest, LANE_INFO_001, TestSize.Level1)
1141 {
1142 LaneLinkInfo info = {};
1143 info.type = LANE_BR;
1144 LaneConnInfo connInfo = {};
1145 LaneProfile profile = {};
1146 int32_t ret = LaneInfoProcess(&info, &connInfo, &profile);
1147 EXPECT_EQ(ret, SOFTBUS_OK);
1148 }
1149
1150 /*
1151 * @tc.name: LANE_INFO_002
1152 * @tc.desc: LaneInfoProcess BLE
1153 * @tc.type: FUNC
1154 * @tc.require:
1155 */
1156 HWTEST_F(LNNLaneMockTest, LANE_INFO_002, TestSize.Level1)
1157 {
1158 LaneLinkInfo info = {};
1159 info.type = LANE_BLE;
1160 LaneConnInfo connInfo = {};
1161 LaneProfile profile = {};
1162 int32_t ret = LaneInfoProcess(&info, &connInfo, &profile);
1163 EXPECT_EQ(ret, SOFTBUS_OK);
1164 }
1165
1166 /*
1167 * @tc.name: LANE_INFO_003
1168 * @tc.desc: LaneInfoProcess P2P
1169 * @tc.type: FUNC
1170 * @tc.require:
1171 */
1172 HWTEST_F(LNNLaneMockTest, LANE_INFO_003, TestSize.Level1)
1173 {
1174 LaneLinkInfo info = {};
1175 info.type = LANE_P2P;
1176 LaneConnInfo connInfo;
1177 LaneProfile profile = {};
1178 int32_t ret = LaneInfoProcess(&info, &connInfo, &profile);
1179 EXPECT_EQ(ret, SOFTBUS_OK);
1180 }
1181
1182 /*
1183 * @tc.name: LANE_INFO_004
1184 * @tc.desc: LaneInfoProcess fail
1185 * @tc.type: FAILUE
1186 * @tc.require:
1187 */
1188 HWTEST_F(LNNLaneMockTest, LANE_INFO_004, TestSize.Level1)
1189 {
1190 LaneLinkInfo info = {};
1191 info.type = LANE_LINK_TYPE_BUTT;
1192 LaneConnInfo *connInfo = nullptr;
1193 LaneProfile *profile = nullptr;
1194 int32_t ret = LaneInfoProcess(nullptr, connInfo, profile);
1195 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1196
1197 ret = LaneInfoProcess(&info, nullptr, profile);
1198 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1199
1200 ret = LaneInfoProcess(&info, connInfo, nullptr);
1201 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1202
1203 ret = LaneInfoProcess(&info, connInfo, profile);
1204 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1205 }
1206
1207 /*
1208 * @tc.name: LANE_INFO_005
1209 * @tc.desc: LaneInfoProcess 2.4G
1210 * @tc.type: FUNC
1211 * @tc.require:
1212 */
1213 HWTEST_F(LNNLaneMockTest, LANE_INFO_005, TestSize.Level1)
1214 {
1215 LaneLinkInfo info = {};
1216 LaneConnInfo connInfo = {};
1217 LaneProfile profile = {};
1218
1219 info.type = LANE_WLAN_2P4G;
1220 int32_t ret = LaneInfoProcess(&info, &connInfo, &profile);
1221 EXPECT_EQ(ret, SOFTBUS_OK);
1222
1223 info.type = LANE_WLAN_5G;
1224 ret = LaneInfoProcess(&info, &connInfo, &profile);
1225 EXPECT_EQ(ret, SOFTBUS_OK);
1226
1227 info.type = LANE_P2P_REUSE;
1228 ret = LaneInfoProcess(&info, &connInfo, &profile);
1229 EXPECT_EQ(ret, SOFTBUS_OK);
1230
1231 info.type = LANE_BLE_DIRECT;
1232 ret = LaneInfoProcess(&info, &connInfo, &profile);
1233 EXPECT_EQ(ret, SOFTBUS_OK);
1234
1235 info.type = LANE_COC;
1236 ret = LaneInfoProcess(&info, &connInfo, &profile);
1237 EXPECT_EQ(ret, SOFTBUS_OK);
1238 }
1239
1240 /*
1241 * @tc.name: LNN_DATA_001
1242 * @tc.desc: LnnCreateData
1243 * @tc.type: FUNC
1244 * @tc.require:
1245 */
1246 HWTEST_F(LNNLaneMockTest, LNN_DATA_001, TestSize.Level1)
1247 {
1248 int32_t ret = LnnCreateData(nullptr, 32, nullptr, 0);
1249 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1250
1251 LnnDeleteData(nullptr, 32);
1252 }
1253
1254 /*
1255 * @tc.name: LNN_LANE_PROFILE_001
1256 * @tc.desc: BindLaneIdToProfile
1257 * @tc.type: FUNC
1258 * @tc.require:
1259 */
1260 HWTEST_F(LNNLaneMockTest, LNN_LANE_PROFILE_001, TestSize.Level1)
1261 {
1262 uint64_t laneId = 0x1000000000000001;
1263 int32_t ret = BindLaneIdToProfile(laneId, nullptr);
1264 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1265
1266 LaneProfile profile = {};
1267 ret = BindLaneIdToProfile(laneId, &profile);
1268 EXPECT_EQ(ret, SOFTBUS_OK);
1269
1270 profile.linkType = LANE_P2P;
1271 profile.content = LANE_T_FILE;
1272 profile.priority = LANE_PRI_LOW;
1273 ret = BindLaneIdToProfile(laneId, &profile);
1274 EXPECT_EQ(ret, SOFTBUS_OK);
1275
1276 LaneGenerateParam param = {};
1277 param.linkType = LANE_P2P;
1278 param.transType = LANE_T_FILE;
1279 param.priority = LANE_PRI_LOW;
1280 uint32_t profileId = GenerateLaneProfileId(¶m);
1281
1282 ret = GetLaneProfile(profileId, &profile);
1283 EXPECT_EQ(ret, SOFTBUS_OK);
1284
1285 ret = GetLaneProfile(profileId, nullptr);
1286 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1287
1288 uint64_t *laneReqIdList = nullptr;
1289 uint32_t listSize = 0;
1290 ret = GetLaneIdList(profileId, &laneReqIdList, &listSize);
1291 EXPECT_EQ(ret, SOFTBUS_OK);
1292 SoftBusFree(laneReqIdList);
1293
1294 (void)GetActiveProfileNum();
1295
1296 (void)UnbindLaneIdFromProfile(laneId, profileId);
1297
1298 (void)UnbindLaneIdFromProfile(0, profileId);
1299 }
1300
1301 /*
1302 * @tc.name: LNN_SELECT_LANE_001
1303 * @tc.desc: SelectLane
1304 * @tc.type: FUNC
1305 * @tc.require:
1306 */
1307 HWTEST_F(LNNLaneMockTest, LNN_SELECT_LANE_001, TestSize.Level1)
1308 {
1309 NiceMock<LaneDepsInterfaceMock> mock;
1310 LanePreferredLinkList *linkList = nullptr;
1311 uint32_t listNum = 0;
1312 LaneSelectParam selectParam = {};
1313 selectParam.transType = LANE_T_FILE;
1314 selectParam.expectedBw = 0;
1315 selectParam.list.linkTypeNum = 2;
1316 selectParam.list.linkType[0] = LANE_WLAN_5G;
1317 selectParam.list.linkType[1] = LANE_LINK_TYPE_BUTT;
1318
1319 int32_t ret = SelectLane(NODE_NETWORK_ID, nullptr, linkList, &listNum);
1320 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1321
1322 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
1323 EXPECT_CALL(mock, LnnGetLocalNumInfo).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
1324 EXPECT_CALL(mock, LnnGetRemoteNumInfo).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
1325 EXPECT_CALL(mock, LnnGetOnlineStateById).WillRepeatedly(Return(false));
1326 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1327 wifiMock.SetDefaultResult();
1328 ret = SelectLane(NODE_NETWORK_ID, &selectParam, linkList, &listNum);
1329 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1330
1331 EXPECT_CALL(mock, LnnGetLocalNumInfo)
1332 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(0), Return(SOFTBUS_OK)));
1333 EXPECT_CALL(mock, LnnGetRemoteNumInfo)
1334 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(0), Return(SOFTBUS_OK)));
1335 EXPECT_CALL(mock, LnnGetOnlineStateById).WillRepeatedly(Return(true));
1336 ret = SelectLane(NODE_NETWORK_ID, &selectParam, linkList, &listNum);
1337 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1338
1339 selectParam.transType = LANE_T_MIX;
1340 ret = SelectLane(NODE_NETWORK_ID, &selectParam, linkList, &listNum);
1341 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1342 SoftBusFree(linkList);
1343 }
1344
1345 /*
1346 * @tc.name: LNN_SELECT_LANE_002
1347 * @tc.desc: SelectLane
1348 * @tc.type: FUNC
1349 * @tc.require:
1350 */
1351 HWTEST_F(LNNLaneMockTest, LNN_SELECT_LANE_002, TestSize.Level1)
1352 {
1353 NiceMock<LaneDepsInterfaceMock> mock;
1354 LanePreferredLinkList *linkList = nullptr;
1355 uint32_t listNum = 0;
1356 LaneSelectParam selectParam = {};
1357 selectParam.transType = LANE_T_FILE;
1358 selectParam.expectedBw = 0;
1359 selectParam.list.linkTypeNum = DEFAULT_SELECT_NUM;
1360 selectParam.list.linkType[0] = LANE_BLE;
1361 selectParam.list.linkType[1] = LANE_WLAN_2P4G;
1362 selectParam.list.linkType[2] = LANE_WLAN_5G;
1363 selectParam.list.linkType[3] = LANE_BR;
1364
1365 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
1366 EXPECT_CALL(mock, LnnGetLocalNumInfo).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
1367 EXPECT_CALL(mock, LnnGetRemoteNumInfo).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
1368 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1369 wifiMock.SetDefaultResult();
1370 int32_t ret = SelectLane(NODE_NETWORK_ID, &selectParam, linkList, &listNum);
1371 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1372
1373 EXPECT_CALL(mock, LnnGetLocalNumInfo)
1374 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(1), Return(SOFTBUS_OK)));
1375 EXPECT_CALL(mock, LnnGetRemoteNumInfo)
1376 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(1), Return(SOFTBUS_OK)));
1377 ret = SelectLane(NODE_NETWORK_ID, &selectParam, linkList, &listNum);
1378 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1379 SoftBusFree(linkList);
1380 }
1381
1382 /*
1383 * @tc.name: LNN_SELECT_LANE_003
1384 * @tc.desc: SelectLane
1385 * @tc.type: FUNC
1386 * @tc.require:
1387 */
1388 HWTEST_F(LNNLaneMockTest, LNN_SELECT_LANE_003, TestSize.Level1)
1389 {
1390 NiceMock<LaneDepsInterfaceMock> mock;
1391 LanePreferredLinkList linkList = {};
1392 uint32_t listNum = 0;
1393 LaneSelectParam selectParam = {};
1394 NodeInfo node = {};
1395
1396 selectParam.transType = LANE_T_FILE;
1397 selectParam.expectedBw = 0;
1398 selectParam.list.linkTypeNum = 7;
1399 selectParam.list.linkType[0] = LANE_P2P;
1400 selectParam.list.linkType[1] = LANE_ETH;
1401 selectParam.list.linkType[2] = LANE_P2P_REUSE;
1402 selectParam.list.linkType[3] = LANE_BLE_DIRECT;
1403 selectParam.list.linkType[4] = LANE_BLE_REUSE;
1404 selectParam.list.linkType[5] = LANE_COC;
1405 selectParam.list.linkType[6] = LANE_COC_DIRECT;
1406 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
1407 EXPECT_CALL(mock, LnnGetLocalNumInfo).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
1408 EXPECT_CALL(mock, LnnGetRemoteNumInfo).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
1409 EXPECT_CALL(mock, LnnGetLocalNumU64Info).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
1410 EXPECT_CALL(mock, LnnGetRemoteNumU64Info).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
1411 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1412 wifiMock.SetDefaultResult();
1413 int32_t ret = SelectLane(NODE_NETWORK_ID, &selectParam, &linkList, &listNum);
1414 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_OFF);
1415
1416 node.discoveryType = 3;
1417 EXPECT_CALL(mock, LnnGetRemoteNodeInfoById)
1418 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(node), Return(SOFTBUS_OK)));
1419 EXPECT_CALL(mock, LnnGetLocalNumInfo)
1420 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(1), Return(SOFTBUS_OK)));
1421 EXPECT_CALL(mock, LnnGetRemoteNumInfo)
1422 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(1), Return(SOFTBUS_OK)));
1423 EXPECT_CALL(mock, LnnGetLocalNumU64Info)
1424 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(1), Return(SOFTBUS_OK)));
1425 EXPECT_CALL(mock, LnnGetRemoteNumU64Info)
1426 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(1), Return(SOFTBUS_OK)));
1427 ret = SelectLane(NODE_NETWORK_ID, &selectParam, &linkList, &listNum);
1428 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_OFF);
1429 }
1430
1431 /*
1432 * @tc.name: LNN_SELECT_LANE_004
1433 * @tc.desc: SelectLane, HmlIsExist == true
1434 * @tc.type: FUNC
1435 * @tc.require:
1436 */
1437 HWTEST_F(LNNLaneMockTest, LNN_SELECT_LANE_004, TestSize.Level1)
1438 {
1439 LaneSelectParam request = {};
1440 request.transType = LANE_T_FILE;
1441 request.list.linkTypeNum = 0;
1442 request.list.linkType[(request.list.linkTypeNum)++] = LANE_BR;
1443 request.list.linkType[(request.list.linkTypeNum)++] = LANE_BLE;
1444 request.list.linkType[(request.list.linkTypeNum)++] = LANE_P2P;
1445 request.list.linkType[(request.list.linkTypeNum)++] = LANE_HML;
1446
1447 LanePreferredLinkList recommendList = {};
1448 uint32_t listNum = 0;
1449
1450 NiceMock<LaneDepsInterfaceMock> linkMock;
1451 EXPECT_CALL(linkMock, LnnGetOnlineStateById).WillRepeatedly(Return(true));
1452 EXPECT_CALL(linkMock, LnnGetLocalNumU32Info)
1453 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(11), Return(SOFTBUS_OK)));
1454 EXPECT_CALL(linkMock, LnnGetRemoteNumU32Info)
1455 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(11), Return(SOFTBUS_OK)));
1456 EXPECT_CALL(linkMock, LnnGetLocalNumU64Info)
1457 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(8), Return(SOFTBUS_OK)));
1458 EXPECT_CALL(linkMock, LnnGetRemoteNumU64Info)\
1459 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(8), Return(SOFTBUS_OK)));
1460
1461 int32_t ret = SelectLane(NODE_NETWORK_ID, &request, &recommendList, &listNum);
1462 EXPECT_EQ(ret, SOFTBUS_OK);
1463 }
1464
1465 /*
1466 * @tc.name: LNN_SELECT_LANE_005
1467 * @tc.desc: SelectLane, HmlIsExist == false && LaneAddHml
1468 * @tc.type: FUNC
1469 * @tc.require:
1470 */
1471 HWTEST_F(LNNLaneMockTest, LNN_SELECT_LANE_005, TestSize.Level1)
1472 {
1473 LaneSelectParam request = {};
1474 request.transType = LANE_T_FILE;
1475 request.list.linkTypeNum = 0;
1476 request.list.linkType[(request.list.linkTypeNum)++] = LANE_BR;
1477 request.list.linkType[(request.list.linkTypeNum)++] = LANE_BLE;
1478 request.list.linkType[(request.list.linkTypeNum)++] = LANE_P2P;
1479
1480 LanePreferredLinkList recommendList = {};
1481 uint32_t listNum = 0;
1482
1483 NiceMock<LaneDepsInterfaceMock> linkMock;
1484 EXPECT_CALL(linkMock, LnnGetOnlineStateById).WillRepeatedly(Return(true));
1485 EXPECT_CALL(linkMock, LnnGetLocalNumU32Info)
1486 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(11), Return(SOFTBUS_OK)));
1487 EXPECT_CALL(linkMock, LnnGetRemoteNumU32Info)
1488 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(11), Return(SOFTBUS_OK)));
1489 EXPECT_CALL(linkMock, LnnGetLocalNumU64Info)
1490 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(8), Return(SOFTBUS_OK)));
1491 EXPECT_CALL(linkMock, LnnGetRemoteNumU64Info)
1492 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(8), Return(SOFTBUS_OK)));
1493
1494 int32_t ret = SelectLane(NODE_NETWORK_ID, &request, &recommendList, &listNum);
1495 EXPECT_EQ(ret, SOFTBUS_OK);
1496 }
1497
1498 /*
1499 * @tc.name: LNN_BUILD_LINK_001
1500 * @tc.desc: BUILDLINK
1501 * @tc.type: FUNC
1502 * @tc.require:
1503 */
1504 HWTEST_F(LNNLaneMockTest, LNN_BUILD_LINK_001, TestSize.Level1)
1505 {
1506 LinkRequest reqInfo = {};
1507 reqInfo.linkType = LANE_P2P;
1508 LaneLinkCb cb = {
1509 .onLaneLinkSuccess = OnLaneLinkSuccess,
1510 .onLaneLinkFail = OnLaneLinkFail,
1511 };
1512 int32_t ret;
1513 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1514 EXPECT_CALL(wifiMock, LnnDisconnectP2p).WillRepeatedly(Return(SOFTBUS_OK));
1515 EXPECT_CALL(wifiMock, LnnConnectP2p)
1516 .WillOnce(Return(SOFTBUS_LANE_BUILD_LINK_FAIL))
1517 .WillRepeatedly(Return(SOFTBUS_OK));
1518 ret = BuildLink(&reqInfo, 0, &cb);
1519 EXPECT_EQ(ret, SOFTBUS_LANE_BUILD_LINK_FAIL);
1520
1521 ret = BuildLink(&reqInfo, 0, &cb);
1522 EXPECT_TRUE(ret == SOFTBUS_OK);
1523
1524 cb.onLaneLinkFail = nullptr;
1525 ret = BuildLink(&reqInfo, 0, &cb);
1526 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1527
1528 cb.onLaneLinkSuccess = nullptr;
1529 ret = BuildLink(&reqInfo, 0, &cb);
1530 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1531
1532 ret = BuildLink(&reqInfo, 0, nullptr);
1533 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1534
1535 reqInfo.linkType = LANE_BLE;
1536 ret = BuildLink(&reqInfo, 0, nullptr);
1537 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1538
1539 reqInfo.linkType = LANE_LINK_TYPE_BUTT;
1540 ret = BuildLink(&reqInfo, 0, &cb);
1541 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1542
1543 ret = BuildLink(nullptr, 0, nullptr);
1544 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1545
1546 ret = DestroyLink(NODE_NETWORK_ID, 0, LANE_BLE);
1547 EXPECT_TRUE(ret == SOFTBUS_OK);
1548
1549 EXPECT_CALL(wifiMock, LnnDestroyP2p).WillRepeatedly(Return());
1550 ret = DestroyLink(NODE_NETWORK_ID, 0, LANE_P2P);
1551 EXPECT_TRUE(ret == SOFTBUS_OK);
1552 ret = DestroyLink(nullptr, 0, LANE_P2P);
1553 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1554 }
1555
1556 /*
1557 * @tc.name: LNN_BUILD_LINK_002
1558 * @tc.desc: BUILDLINK
1559 * @tc.type: FUNC
1560 * @tc.require:
1561 */
1562 HWTEST_F(LNNLaneMockTest, LNN_BUILD_LINK_002, TestSize.Level1)
1563 {
1564 NiceMock<LaneDepsInterfaceMock> mock;
1565 LinkRequest reqInfo = {};
1566 reqInfo.linkType = LANE_P2P;
1567 LaneLinkCb cb = {
1568 .onLaneLinkSuccess = OnLaneLinkSuccess,
1569 .onLaneLinkFail = OnLaneLinkFail,
1570 };
1571 int32_t ret;
1572 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1573 const char *udid = "testuuid";
1574 EXPECT_CALL(mock, LnnGetRemoteStrInfo).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
1575 ret = BuildLink(&reqInfo, 0, &cb);
1576 EXPECT_TRUE(ret == SOFTBUS_OK);
1577 EXPECT_CALL(mock, LnnConvertDLidToUdid).WillRepeatedly(Return(udid));
1578 EXPECT_CALL(mock, ConnBleGetClientConnectionByUdid).WillRepeatedly(Return(NULL));
1579 EXPECT_CALL(mock, LnnGetRemoteNodeInfoById).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
1580 ON_CALL(wifiMock, LnnConnectP2p).WillByDefault(Return(SOFTBUS_LANE_BUILD_LINK_FAIL));
1581 ret = BuildLink(&reqInfo, 0, &cb);
1582 EXPECT_EQ(ret, SOFTBUS_LANE_BUILD_LINK_FAIL);
1583 }
1584
1585 /*
1586 * @tc.name: LNN_BUILD_LINK_003
1587 * @tc.desc: BUILDLINK
1588 * @tc.type: FUNC
1589 * @tc.require:
1590 */
1591 HWTEST_F(LNNLaneMockTest, LNN_BUILD_LINK_003, TestSize.Level1)
1592 {
1593 NiceMock<LaneDepsInterfaceMock> mock;
1594 LinkRequest reqInfo = {};
1595 reqInfo.linkType = LANE_P2P;
1596 LaneLinkCb cb = {
1597 .onLaneLinkSuccess = OnLaneLinkSuccess,
1598 .onLaneLinkFail = OnLaneLinkFail,
1599 };
1600 int32_t ret;
1601 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1602
1603 ConnBleConnection *connection = (ConnBleConnection*)SoftBusCalloc(sizeof(ConnBleConnection));
1604 if (connection == NULL) {
1605 return;
1606 }
1607 const char *udid = "testuuid";
1608 NodeInfo *nodeInfo = (NodeInfo*)SoftBusCalloc(sizeof(NodeInfo));
1609 if (nodeInfo == NULL) {
1610 return;
1611 }
1612 connection->state = BLE_CONNECTION_STATE_EXCHANGED_BASIC_INFO;
1613 EXPECT_CALL(mock, LnnConvertDLidToUdid).WillRepeatedly(Return(udid));
1614 EXPECT_CALL(mock, ConnBleGetClientConnectionByUdid).WillRepeatedly(Return(connection));
1615 EXPECT_CALL(mock, LnnGetRemoteNodeInfoById).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
1616 EXPECT_CALL(wifiMock, LnnConnectP2p).WillRepeatedly(Return(SOFTBUS_OK));
1617 EXPECT_CALL(mock, LnnGetLocalNodeInfo).WillRepeatedly(Return(nodeInfo));
1618 ret = BuildLink(&reqInfo, 0, &cb);
1619 EXPECT_TRUE(ret == SOFTBUS_OK);
1620 SoftBusFree(connection);
1621 SoftBusFree(nodeInfo);
1622 }
1623
1624 /*
1625 * @tc.name: LNN_BUILD_LINK_004
1626 * @tc.desc: BUILDLINK
1627 * @tc.type: FUNC
1628 * @tc.require:
1629 */
1630 HWTEST_F(LNNLaneMockTest, LNN_BUILD_LINK_004, TestSize.Level1)
1631 {
1632 NiceMock<LaneDepsInterfaceMock> mock;
1633 LinkRequest reqInfo = {};
1634 int32_t ret;
1635 const char *udid = "testuuid";
1636 LaneLinkCb cb = {
1637 .onLaneLinkSuccess = OnLaneLinkSuccess,
1638 .onLaneLinkFail = OnLaneLinkFail,
1639 };
1640
1641 reqInfo.linkType = LANE_BLE;
1642 EXPECT_CALL(mock, LnnConvertDLidToUdid).WillRepeatedly(Return(udid));
1643 EXPECT_CALL(mock, ConnBleGetClientConnectionByUdid).WillRepeatedly(Return(nullptr));
1644 ON_CALL(mock, LnnGetRemoteStrInfo).WillByDefault(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
1645 ret = BuildLink(&reqInfo, 0, &cb);
1646 EXPECT_NE(ret, SOFTBUS_OK);
1647
1648 EXPECT_CALL(mock, LnnGetRemoteStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
1649 ON_CALL(mock, SoftBusGenerateStrHash).WillByDefault(Return(SOFTBUS_ENCRYPT_ERR));
1650 ret = BuildLink(&reqInfo, 0, &cb);
1651 EXPECT_NE(ret, SOFTBUS_OK);
1652 ret = BuildLink(&reqInfo, 0, &cb);
1653 EXPECT_NE(ret, SOFTBUS_OK);
1654 }
1655
1656 /*
1657 * @tc.name: LNN_BUILD_LINK_005
1658 * @tc.desc: BUILDLINK
1659 * @tc.type: FUNC
1660 * @tc.require:
1661 */
1662 HWTEST_F(LNNLaneMockTest, LNN_BUILD_LINK_005, TestSize.Level1)
1663 {
1664 NiceMock<LaneDepsInterfaceMock> mock;
1665 LinkRequest reqInfo = {};
1666 int32_t ret;
1667 const char *udid = "testuuid";
1668 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1669 LaneLinkCb cb = {
1670 .onLaneLinkSuccess = OnLaneLinkSuccess,
1671 .onLaneLinkFail = OnLaneLinkFail,
1672 };
1673
1674 reqInfo.linkType = LANE_BLE;
1675 ConnBleConnection *connection = (ConnBleConnection *)SoftBusCalloc(sizeof(ConnBleConnection));
1676 if (connection == nullptr) {
1677 return;
1678 }
1679 connection->state = BLE_CONNECTION_STATE_INVALID;
1680 EXPECT_CALL(mock, LnnConvertDLidToUdid).WillRepeatedly(Return(udid));
1681 EXPECT_CALL(mock, ConnBleGetClientConnectionByUdid).WillRepeatedly(Return(connection));
1682 EXPECT_CALL(mock, LnnGetRemoteStrInfo).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
1683 ON_CALL(mock, LnnGetRemoteNodeInfoById).WillByDefault(Return(SOFTBUS_OK));
1684 ret = BuildLink(&reqInfo, 0, &cb);
1685 EXPECT_TRUE(ret == SOFTBUS_LANE_GET_LEDGER_INFO_ERR);
1686 SoftBusFree(connection);
1687 }
1688
1689 /*
1690 * @tc.name: LNN_BUILD_LINK_006
1691 * @tc.desc: BUILDLINK
1692 * @tc.type: FUNC
1693 * @tc.require:
1694 */
1695 HWTEST_F(LNNLaneMockTest, LNN_BUILD_LINK_006, TestSize.Level1)
1696 {
1697 uint32_t reqId = 0;
1698 const char *networkId = "testnetworkid123";
1699 const char *networkIdNotFound = "testnetworkid133";
1700 const char *ipAddr = "127.0.0.1";
1701 const char *ipAddrDiff = "127.0.0.2";
1702 uint16_t portA = 22;
1703 uint16_t portB = 33;
1704 LaneLinkCb cb = {
1705 .onLaneLinkSuccess = OnLaneLinkSuccess,
1706 .onLaneLinkFail = OnLaneLinkFail,
1707 };
1708 NiceMock<LaneDepsInterfaceMock> mock;
1709 EXPECT_CALL(mock, LnnGetRemoteStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
1710 LinkRequest *request = (LinkRequest *)SoftBusCalloc(sizeof(LinkRequest));
1711 if (request == nullptr) {
1712 return;
1713 }
1714 LaneAddP2pAddress(networkId, ipAddr, portA);
1715 LaneAddP2pAddress(networkId, ipAddr, portB);
1716 LaneAddP2pAddressByIp(ipAddr, portB);
1717 LaneAddP2pAddressByIp(ipAddrDiff, portB);
1718 request->linkType = LANE_P2P_REUSE;
1719 (void)strcpy_s(request->peerNetworkId, NETWORK_ID_BUF_LEN, networkId);
1720 int32_t ret = BuildLink(request, reqId, &cb);
1721 EXPECT_TRUE(ret == SOFTBUS_OK);
1722
1723 (void)strcpy_s(request->peerNetworkId, NETWORK_ID_BUF_LEN, networkIdNotFound);
1724 ret = BuildLink(request, reqId, &cb);
1725 EXPECT_TRUE(ret == SOFTBUS_LANE_NOT_FOUND);
1726 SoftBusFree(request);
1727 LaneDeleteP2pAddress(networkId, true);
1728 }
1729
1730 /*
1731 * @tc.name: LNN_BUILD_LINK_007
1732 * @tc.desc: BUILDLINK
1733 * @tc.type: FUNC
1734 * @tc.require:
1735 */
1736 HWTEST_F(LNNLaneMockTest, LNN_BUILD_LINK_007, TestSize.Level1)
1737 {
1738 NiceMock<LaneDepsInterfaceMock> mock;
1739 uint32_t reqId = 0;
1740 LaneLinkCb cb = {
1741 .onLaneLinkSuccess = OnLaneLinkSuccess,
1742 .onLaneLinkFail = OnLaneLinkFail,
1743 };
1744 LinkRequest *request = (LinkRequest *)SoftBusCalloc(sizeof(LinkRequest));
1745 if (request == nullptr) {
1746 return;
1747 }
1748 NodeInfo *nodeInfo = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
1749 if (nodeInfo == nullptr) {
1750 SoftBusFree(request);
1751 return;
1752 }
1753 request->linkType = LANE_BLE_DIRECT;
1754 EXPECT_CALL(mock, LnnGetRemoteStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
1755 EXPECT_CALL(mock, LnnGetLocalNodeInfo).WillRepeatedly(Return(nodeInfo));
1756
1757 int32_t ret = BuildLink(request, reqId, &cb);
1758 ret = BuildLink(request, reqId, &cb);
1759 EXPECT_TRUE(ret == SOFTBUS_OK);
1760 SoftBusFree(request);
1761 SoftBusFree(nodeInfo);
1762 }
1763
1764 /*
1765 * @tc.name: LNN_BUILD_LINK_008
1766 * @tc.desc: BUILDLINK
1767 * @tc.type: FUNC
1768 * @tc.require:
1769 */
1770 HWTEST_F(LNNLaneMockTest, LNN_BUILD_LINK_008, TestSize.Level1)
1771 {
1772 NiceMock<LaneDepsInterfaceMock> mock;
1773 LinkRequest reqInfo = {};
1774 int32_t ret;
1775 const char *udid = "testuuid";
1776 const char *bleMac = "127.1.1.1";
1777 LaneLinkCb cb = {
1778 .onLaneLinkSuccess = OnLaneLinkSuccess,
1779 .onLaneLinkFail = OnLaneLinkFail,
1780 };
1781
1782 reqInfo.linkType = LANE_COC;
1783 if (strcpy_s(reqInfo.peerBleMac, MAX_MAC_LEN, bleMac) != EOK) {
1784 return;
1785 }
1786 EXPECT_CALL(mock, LnnConvertDLidToUdid).WillRepeatedly(Return(udid));
1787 EXPECT_CALL(mock, ConnBleGetClientConnectionByUdid).WillRepeatedly(Return(nullptr));
1788 EXPECT_CALL(mock, LnnGetRemoteStrInfo).WillOnce(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
1789 ret = BuildLink(&reqInfo, 0, &cb);
1790 EXPECT_EQ(ret, SOFTBUS_LANE_GET_LEDGER_INFO_ERR);
1791
1792 EXPECT_CALL(mock, LnnGetRemoteStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
1793 EXPECT_CALL(mock, SoftBusGenerateStrHash)
1794 .WillOnce(Return(SOFTBUS_ENCRYPT_ERR))
1795 .WillRepeatedly(LaneDepsInterfaceMock::ActionOfGenerateStrHash);
1796 ret = BuildLink(&reqInfo, 0, &cb);
1797 EXPECT_EQ(ret, SOFTBUS_ENCRYPT_ERR);
1798 ret = BuildLink(&reqInfo, 0, &cb);
1799 EXPECT_TRUE(ret == SOFTBUS_OK);
1800 }
1801
1802 /*
1803 * @tc.name: LNN_BUILD_LINK_009
1804 * @tc.desc: BUILDLINK
1805 * @tc.type: FUNC
1806 * @tc.require:
1807 */
1808 HWTEST_F(LNNLaneMockTest, LNN_BUILD_LINK_009, TestSize.Level1)
1809 {
1810 uint32_t reqId = 0;
1811 const char *networkId = "testnetworkid123";
1812 const char *networkIdNotFound = "testnetworkid133";
1813 LaneLinkCb cb = {
1814 .onLaneLinkSuccess = OnLaneLinkSuccess,
1815 .onLaneLinkFail = OnLaneLinkFail,
1816 };
1817 NiceMock<LaneDepsInterfaceMock> mock;
1818 EXPECT_CALL(mock, LnnGetRemoteStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
1819 LinkRequest *request = (LinkRequest *)SoftBusCalloc(sizeof(LinkRequest));
1820 if (request == nullptr) {
1821 return;
1822 }
1823 request->linkType = LANE_COC_DIRECT;
1824 if (strcpy_s(request->peerNetworkId, NETWORK_ID_BUF_LEN, networkId) != EOK) {
1825 return;
1826 }
1827 int32_t ret = BuildLink(request, reqId, &cb);
1828 EXPECT_TRUE(ret == SOFTBUS_OK);
1829
1830 if (strcpy_s(request->peerNetworkId, NETWORK_ID_BUF_LEN, networkIdNotFound) != EOK) {
1831 return;
1832 }
1833 ret = BuildLink(request, reqId, &cb);
1834 EXPECT_TRUE(ret == SOFTBUS_OK);
1835 SoftBusFree(request);
1836 LaneDeleteP2pAddress(networkId, true);
1837 }
1838
1839 /*
1840 * @tc.name: LNN_BUILD_LINK_010
1841 * @tc.desc: BUILDLINK
1842 * @tc.type: FUNC
1843 * @tc.require:
1844 */
1845 HWTEST_F(LNNLaneMockTest, LNN_BUILD_LINK_010, TestSize.Level1)
1846 {
1847 NiceMock<LaneDepsInterfaceMock> mock;
1848 LinkRequest reqInfo = {};
1849 int32_t ret;
1850 const char *udid = "testuuid";
1851 const char *bleMac = "127.1.1.1";
1852 LaneLinkCb cb = {
1853 .onLaneLinkSuccess = OnLaneLinkSuccess,
1854 .onLaneLinkFail = OnLaneLinkFail,
1855 };
1856 ConnBleConnection *connection = (ConnBleConnection *)SoftBusCalloc(sizeof(ConnBleConnection));
1857 if (connection == nullptr) {
1858 return;
1859 }
1860 connection->state = BLE_CONNECTION_STATE_EXCHANGED_BASIC_INFO;
1861 reqInfo.linkType = LANE_BLE_REUSE;
1862 if (strcpy_s(reqInfo.peerBleMac, MAX_MAC_LEN, bleMac) != EOK) {
1863 return;
1864 }
1865 ON_CALL(mock, ConnBleGetConnectionByUdid).WillByDefault(Return(connection));
1866 ON_CALL(mock, ConnBleReturnConnection).WillByDefault(Return());
1867 EXPECT_CALL(mock, LnnConvertDLidToUdid).WillRepeatedly(Return(udid));
1868 EXPECT_CALL(mock, SoftBusGenerateStrHash).WillRepeatedly(Return(SOFTBUS_OK));
1869 EXPECT_CALL(mock, LnnGetRemoteStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
1870 ret = BuildLink(&reqInfo, 0, &cb);
1871 EXPECT_TRUE(ret == SOFTBUS_OK);
1872
1873 EXPECT_CALL(mock, ConnBleGetConnectionByUdid).WillRepeatedly(Return(connection));
1874 ret = BuildLink(&reqInfo, 0, &cb);
1875 EXPECT_TRUE(ret == SOFTBUS_OK);
1876 SoftBusFree(connection);
1877 }
1878
1879 /*
1880 * @tc.name: LANE_ADD_P2P_ADDRESS_TEST_001
1881 * @tc.desc: LANE ADD P2P ADDRESS TEST
1882 * @tc.type: FUNC
1883 * @tc.require:
1884 */
1885 HWTEST_F(LNNLaneMockTest, LANE_ADD_P2P_ADDRESS_TEST_001, TestSize.Level1)
1886 {
1887 const char *networkId = "testnetworkid123";
1888 const char *ipAddr = "127.0.0.1";
1889 uint16_t port = 1022;
1890 LaneAddP2pAddress(networkId, ipAddr, port);
1891 LaneAddP2pAddressByIp(ipAddr, port);
1892 LaneUpdateP2pAddressByIp(ipAddr, networkId);
1893 }
1894
1895 /*
1896 * @tc.name: LNN_SELECT_EXPECT_LANES_BY_QOS_001
1897 * @tc.desc: SelectExpectLanesByQos
1898 * @tc.type: FUNC
1899 * @tc.require:
1900 */
1901 HWTEST_F(LNNLaneMockTest, LNN_SELECT_EXPECT_LANES_BY_QOS_001, TestSize.Level1)
1902 {
1903 NiceMock<LaneDepsInterfaceMock> mock;
1904 LanePreferredLinkList linkList;
1905 LaneSelectParam selectParam = {};
1906 selectParam.transType = LANE_T_FILE;
1907 selectParam.qosRequire.minBW = DEFAULT_QOSINFO_MIN_BW;
1908 selectParam.qosRequire.maxLaneLatency = DEFAULT_QOSINFO_MAX_LATENCY;
1909 selectParam.qosRequire.minLaneLatency = DEFAULT_QOSINFO_MIN_LATENCY;
1910 int32_t ret = SelectExpectLanesByQos(NODE_NETWORK_ID, nullptr, &linkList);
1911 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1912
1913 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1914 wifiMock.SetDefaultResult();
1915 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
1916 EXPECT_CALL(mock, LnnGetLocalNumInfo).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
1917 EXPECT_CALL(mock, LnnGetRemoteNumInfo).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
1918 EXPECT_CALL(mock, LnnGetOnlineStateById).WillRepeatedly(Return(false));
1919 ret = SelectExpectLanesByQos(NODE_NETWORK_ID, &selectParam, &linkList);
1920 EXPECT_EQ(ret, SOFTBUS_NETWORK_NODE_OFFLINE);
1921
1922 EXPECT_CALL(mock, LnnGetLocalNumInfo)
1923 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(0), Return(SOFTBUS_OK)));
1924 EXPECT_CALL(mock, LnnGetRemoteNumInfo)
1925 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(0), Return(SOFTBUS_OK)));
1926 EXPECT_CALL(mock, LnnGetOnlineStateById).WillRepeatedly(Return(true));
1927 ret = SelectExpectLanesByQos(NODE_NETWORK_ID, &selectParam, &linkList);
1928 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_OFF);
1929
1930 selectParam.qosRequire.minBW = DEFAULT_QOSINFO_MIN_BW + LOW_BW;
1931 ret = SelectExpectLanesByQos(NODE_NETWORK_ID, &selectParam, &linkList);
1932 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_OFF);
1933
1934 selectParam.qosRequire.minBW = DEFAULT_QOSINFO_MIN_BW + HIGH_BW;
1935 ret = SelectExpectLanesByQos(NODE_NETWORK_ID, &selectParam, &linkList);
1936 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_OFF);
1937
1938 selectParam.transType = LANE_T_MIX;
1939 ret = SelectExpectLanesByQos(NODE_NETWORK_ID, &selectParam, &linkList);
1940 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_OFF);
1941 }
1942
1943 /*
1944 * @tc.name: LNN_SELECT_EXPECT_LANES_BY_QOS_002
1945 * @tc.desc: SelectExpectLanesByQos
1946 * @tc.type: FUNC
1947 * @tc.require:
1948 */
1949 HWTEST_F(LNNLaneMockTest, LNN_SELECT_EXPECT_LANES_BY_QOS_002, TestSize.Level1)
1950 {
1951 NiceMock<LaneDepsInterfaceMock> mock;
1952 LanePreferredLinkList linkList;
1953 LaneSelectParam selectParam = {};
1954 selectParam.transType = LANE_T_FILE;
1955 int32_t ret = SelectExpectLanesByQos(NODE_NETWORK_ID, nullptr, &linkList);
1956 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1957
1958 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
1959 EXPECT_CALL(mock, LnnGetLocalNumInfo).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
1960 EXPECT_CALL(mock, LnnGetRemoteNumInfo).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
1961 EXPECT_CALL(mock, LnnGetOnlineStateById).WillRepeatedly(Return(false));
1962 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1963 wifiMock.SetDefaultResult();
1964 ret = SelectExpectLanesByQos(NODE_NETWORK_ID, &selectParam, &linkList);
1965 EXPECT_EQ(ret, SOFTBUS_NETWORK_NODE_OFFLINE);
1966
1967 EXPECT_CALL(mock, LnnGetLocalNumInfo)
1968 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(1), Return(SOFTBUS_OK)));
1969 EXPECT_CALL(mock, LnnGetRemoteNumInfo)
1970 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(1), Return(SOFTBUS_OK)));
1971 EXPECT_CALL(mock, LnnGetOnlineStateById).WillRepeatedly(Return(true));
1972 ret = SelectExpectLanesByQos(NODE_NETWORK_ID, &selectParam, &linkList);
1973 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_OFF);
1974
1975 selectParam.transType = LANE_T_MIX;
1976 ret = SelectExpectLanesByQos(NODE_NETWORK_ID, &selectParam, &linkList);
1977 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1978 }
1979
1980 /*
1981 * @tc.name: LNN_SELECT_EXPECT_LANES_BY_QOS_003
1982 * @tc.desc: SelectExpectLanesByQos
1983 * @tc.type: FUNC
1984 * @tc.require:
1985 */
1986 HWTEST_F(LNNLaneMockTest, LNN_SELECT_EXPECT_LANES_BY_QOS_003, TestSize.Level1)
1987 {
1988 NiceMock<LaneDepsInterfaceMock> mock;
1989 LanePreferredLinkList linkList;
1990 LaneSelectParam selectParam = {};
1991 selectParam.transType = LANE_T_FILE;
1992
1993
1994 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
1995 EXPECT_CALL(mock, LnnGetOnlineStateById).WillRepeatedly(Return(true));
1996 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1997 wifiMock.SetDefaultResult();
1998
1999 selectParam.qosRequire.rttLevel = LANE_RTT_LEVEL_LOW;
2000 int32_t ret = SelectExpectLanesByQos(NODE_NETWORK_ID, &selectParam, &linkList);
2001 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_OFF);
2002 }
2003
2004 /*
2005 * @tc.name: LANE_FLOAD_EXPLORE_001
2006 * @tc.desc: LANE FLOAD EXPLORE TEST
2007 * @tc.type: FUNC
2008 * @tc.require:
2009 */
2010 HWTEST_F(LNNLaneMockTest, LANE_FLOAD_EXPLORE_001, TestSize.Level1)
2011 {
2012 LaneResource resourceItem = {};
2013 resourceItem.clientRef = DEFAULT_LANE_RESOURCE_LANE_REF;
2014 int32_t ret = LaneDetectFload(&resourceItem);
2015 EXPECT_EQ(ret, SOFTBUS_OK);
2016 }
2017
2018 /*
2019 * @tc.name: LANE_DECISION_MODELS_001
2020 * @tc.desc: LANE DECISION MODELS TEST
2021 * @tc.type: FUNC
2022 * @tc.require:
2023 */
2024 HWTEST_F(LNNLaneMockTest, LANE_DECISION_MODELS_001, TestSize.Level1)
2025 {
2026 NiceMock<LaneDepsInterfaceMock> mock;
2027 LaneSelectParam selectParam = {};
2028 LanePreferredLinkList linkList;
2029 selectParam.transType = LANE_T_FILE;
2030 selectParam.qosRequire.minBW = DEFAULT_QOSINFO_MIN_BW;
2031 selectParam.qosRequire.maxLaneLatency = DEFAULT_QOSINFO_MAX_LATENCY;
2032 selectParam.qosRequire.minLaneLatency = DEFAULT_QOSINFO_MIN_LATENCY;
2033
2034 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
2035 wifiMock.SetDefaultResult();
2036 EXPECT_CALL(wifiMock, SoftBusGetLinkBand).WillRepeatedly(Return(BAND_5G));
2037 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
2038 EXPECT_CALL(mock, LnnGetLocalNumInfo)
2039 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(1), Return(SOFTBUS_OK)));
2040 EXPECT_CALL(mock, LnnGetRemoteNumInfo)
2041 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(1), Return(SOFTBUS_OK)));
2042 EXPECT_CALL(mock, LnnGetOnlineStateById).WillRepeatedly(Return(true));
2043
2044 int32_t ret = DecideAvailableLane(NODE_NETWORK_ID, &selectParam, &linkList);
2045 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_OFF);
2046 }
2047
2048 /*
2049 * @tc.name: LANE_FIND_LANERESOURCE_BY_LINKADDR_001
2050 * @tc.desc: LANE FIND LANERESOURCE BY LINK ADDR TEST
2051 * @tc.type: FUNC
2052 * @tc.require:
2053 */
2054 HWTEST_F(LNNLaneMockTest, LANE_FIND_LANERESOURCE_BY_LINKADDR_001, TestSize.Level1)
2055 {
2056 NiceMock<LaneDepsInterfaceMock> mock;
2057 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
2058 LaneLinkInfo linkInfo;
2059 ASSERT_EQ(memset_s(&linkInfo, sizeof(LaneLinkInfo), 0, sizeof(LaneLinkInfo)), EOK);
2060 linkInfo.type = LANE_HML;
2061 ASSERT_EQ(strncpy_s(linkInfo.linkInfo.p2p.connInfo.peerIp, IP_LEN, PEER_IP_HML, strlen(PEER_IP_HML)), EOK);
2062 ASSERT_EQ(strncpy_s(linkInfo.peerUdid, UDID_BUF_LEN, PEER_UDID, strlen(PEER_UDID)), EOK);
2063
2064 LaneResource laneResourse;
2065 ASSERT_EQ(memset_s(&laneResourse, sizeof(LaneResource), 0, sizeof(LaneResource)), EOK);
2066 int32_t ret = FindLaneResourceByLinkAddr(nullptr, &laneResourse);
2067 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2068
2069 ret = FindLaneResourceByLinkAddr(&linkInfo, nullptr);
2070 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2071
2072 ret = FindLaneResourceByLinkAddr(&linkInfo, &laneResourse);
2073 EXPECT_EQ(ret, SOFTBUS_LANE_RESOURCE_NOT_FOUND);
2074
2075 uint64_t laneId = LANE_ID_BASE;
2076 uint32_t clientRef = 0;
2077 ret = AddLaneResourceToPool(&linkInfo, laneId, false);
2078 EXPECT_EQ(ret, SOFTBUS_OK);
2079 clientRef++;
2080
2081 LaneLinkInfo linkInfoFind;
2082 ASSERT_EQ(memset_s(&linkInfoFind, sizeof(LaneLinkInfo), 0, sizeof(LaneLinkInfo)), EOK);
2083 linkInfoFind.type = LANE_HML;
2084 ret = FindLaneResourceByLinkAddr(&linkInfoFind, &laneResourse);
2085 EXPECT_EQ(ret, SOFTBUS_LANE_RESOURCE_NOT_FOUND);
2086
2087 ASSERT_EQ(strncpy_s(linkInfoFind.peerUdid, UDID_BUF_LEN, PEER_UDID, strlen(PEER_UDID)), EOK);
2088 ret = FindLaneResourceByLinkAddr(&linkInfoFind, &laneResourse);
2089 EXPECT_EQ(ret, SOFTBUS_LANE_RESOURCE_NOT_FOUND);
2090
2091 ASSERT_EQ(strncpy_s(linkInfoFind.linkInfo.p2p.connInfo.peerIp, IP_LEN, PEER_IP_HML, strlen(PEER_IP_HML)), EOK);
2092 ret = FindLaneResourceByLinkAddr(&linkInfoFind, &laneResourse);
2093 EXPECT_EQ(ret, SOFTBUS_OK);
2094 EXPECT_FALSE(laneResourse.isServerSide);
2095 EXPECT_EQ(laneResourse.clientRef, clientRef);
2096 EXPECT_EQ(laneResourse.link.type, LANE_HML);
2097 EXPECT_EQ(laneResourse.laneId, LANE_ID_BASE);
2098 EXPECT_STREQ(laneResourse.link.linkInfo.p2p.connInfo.peerIp, PEER_IP_HML);
2099 EXPECT_STREQ(laneResourse.link.peerUdid, PEER_UDID);
2100
2101 DelLaneResourceByLaneId(laneId, false);
2102 EXPECT_EQ(ret, SOFTBUS_OK);
2103 }
2104
2105 /*
2106 * @tc.name: LANE_FIND_LANERESOURCE_BY_LINKTYPE_001
2107 * @tc.desc: LANE FIND LANERESOURCE BY LINK TYPE TEST
2108 * @tc.type: FUNC
2109 * @tc.require:
2110 */
2111 HWTEST_F(LNNLaneMockTest, LANE_FIND_LANERESOURCE_BY_LINKTYPE_001, TestSize.Level1)
2112 {
2113 NiceMock<LaneDepsInterfaceMock> mock;
2114 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
2115 LaneLinkInfo linkInfo;
2116 ASSERT_EQ(memset_s(&linkInfo, sizeof(LaneLinkInfo), 0, sizeof(LaneLinkInfo)), EOK);
2117 linkInfo.type = LANE_HML;
2118 ASSERT_EQ(strncpy_s(linkInfo.linkInfo.p2p.connInfo.peerIp, IP_LEN, PEER_IP_HML, strlen(PEER_IP_HML)), EOK);
2119 ASSERT_EQ(strncpy_s(linkInfo.peerUdid, UDID_BUF_LEN, PEER_UDID, strlen(PEER_UDID)), EOK);
2120
2121 LaneResource laneResourse;
2122 ASSERT_EQ(memset_s(&laneResourse, sizeof(LaneResource), 0, sizeof(LaneResource)), EOK);
2123 int32_t ret = FindLaneResourceByLinkType(nullptr, LANE_HML, &laneResourse);
2124 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2125
2126 ret = FindLaneResourceByLinkType(PEER_UDID, LANE_LINK_TYPE_BUTT, &laneResourse);
2127 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2128
2129 ret = FindLaneResourceByLinkType(PEER_UDID, LANE_HML, nullptr);
2130 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2131
2132 ret = FindLaneResourceByLinkType(PEER_UDID, LANE_HML, &laneResourse);
2133 EXPECT_EQ(ret, SOFTBUS_LANE_RESOURCE_NOT_FOUND);
2134
2135 uint64_t laneId = LANE_ID_BASE;
2136 uint32_t clientRef = 0;
2137 ret = AddLaneResourceToPool(&linkInfo, laneId, false);
2138 EXPECT_EQ(ret, SOFTBUS_OK);
2139 clientRef++;
2140
2141 ret = FindLaneResourceByLinkType(LOCAL_UDID, LANE_HML, &laneResourse);
2142 EXPECT_EQ(ret, SOFTBUS_LANE_RESOURCE_NOT_FOUND);
2143
2144 ret = FindLaneResourceByLinkType(PEER_UDID, LANE_P2P, &laneResourse);
2145 EXPECT_EQ(ret, SOFTBUS_LANE_RESOURCE_NOT_FOUND);
2146
2147 ret = FindLaneResourceByLinkType(PEER_UDID, LANE_HML, &laneResourse);
2148 EXPECT_EQ(ret, SOFTBUS_OK);
2149 EXPECT_FALSE(laneResourse.isServerSide);
2150 EXPECT_EQ(laneResourse.clientRef, clientRef);
2151 EXPECT_EQ(laneResourse.link.type, LANE_HML);
2152 EXPECT_EQ(laneResourse.laneId, LANE_ID_BASE);
2153 EXPECT_STREQ(laneResourse.link.linkInfo.p2p.connInfo.peerIp, PEER_IP_HML);
2154 EXPECT_STREQ(laneResourse.link.peerUdid, PEER_UDID);
2155
2156 DelLaneResourceByLaneId(laneId, false);
2157 EXPECT_EQ(ret, SOFTBUS_OK);
2158 }
2159
2160 /*
2161 * @tc.name: LANE_FIND_LANERESOURCE_BY_LANEID_001
2162 * @tc.desc: LANE FIND LANERESOURCE BY LANEID TEST
2163 * @tc.type: FUNC
2164 * @tc.require:
2165 */
2166 HWTEST_F(LNNLaneMockTest, LANE_FIND_LANERESOURCE_BY_LANEID_001, TestSize.Level1)
2167 {
2168 NiceMock<LaneDepsInterfaceMock> mock;
2169 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
2170 LaneLinkInfo linkInfo;
2171 ASSERT_EQ(memset_s(&linkInfo, sizeof(LaneLinkInfo), 0, sizeof(LaneLinkInfo)), EOK);
2172 linkInfo.type = LANE_HML;
2173 ASSERT_EQ(strncpy_s(linkInfo.linkInfo.p2p.connInfo.peerIp, IP_LEN, PEER_IP_HML, strlen(PEER_IP_HML)), EOK);
2174 ASSERT_EQ(strncpy_s(linkInfo.peerUdid, UDID_BUF_LEN, PEER_UDID, strlen(PEER_UDID)), EOK);
2175
2176 LaneResource laneResourse;
2177 ASSERT_EQ(memset_s(&laneResourse, sizeof(LaneResource), 0, sizeof(LaneResource)), EOK);
2178 uint64_t laneId = INVALID_LANE_ID;
2179 int32_t ret = FindLaneResourceByLaneId(laneId, nullptr);
2180 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2181
2182 ret = FindLaneResourceByLaneId(laneId, &laneResourse);
2183 EXPECT_EQ(ret, SOFTBUS_LANE_RESOURCE_NOT_FOUND);
2184
2185 laneId = LANE_ID_BASE;
2186 uint32_t clientRef = 0;
2187 ret = AddLaneResourceToPool(&linkInfo, laneId, false);
2188 EXPECT_EQ(ret, SOFTBUS_OK);
2189 clientRef++;
2190
2191 ret = FindLaneResourceByLaneId(INVALID_LANE_ID, &laneResourse);
2192 EXPECT_EQ(ret, SOFTBUS_LANE_RESOURCE_NOT_FOUND);
2193
2194 ret = FindLaneResourceByLaneId(laneId, &laneResourse);
2195 EXPECT_EQ(ret, SOFTBUS_OK);
2196 EXPECT_FALSE(laneResourse.isServerSide);
2197 EXPECT_EQ(laneResourse.clientRef, clientRef);
2198 EXPECT_EQ(laneResourse.link.type, LANE_HML);
2199 EXPECT_EQ(laneResourse.laneId, LANE_ID_BASE);
2200 EXPECT_STREQ(laneResourse.link.linkInfo.p2p.connInfo.peerIp, PEER_IP_HML);
2201 EXPECT_STREQ(laneResourse.link.peerUdid, PEER_UDID);
2202
2203 DelLaneResourceByLaneId(laneId, false);
2204 EXPECT_EQ(ret, SOFTBUS_OK);
2205 }
2206
2207 /*
2208 * @tc.name: LANE_DETECT_RELIABILITY_001
2209 * @tc.desc: LANE DETECT RELIABILITY TEST
2210 * @tc.type: FUNC
2211 * @tc.require:
2212 */
2213 HWTEST_F(LNNLaneMockTest, LANE_DETECT_RELIABILITY_001, TestSize.Level1)
2214 {
2215 LaneLinkCb cb = {
2216 .onLaneLinkSuccess = OnLaneLinkSuccess,
2217 .onLaneLinkFail = OnLaneLinkFail,
2218 };
2219
2220 NiceMock<LaneDepsInterfaceMock> mock;
2221 EXPECT_CALL(mock, ConnOpenClientSocket).WillRepeatedly(Return(SOFTBUS_OK));
2222 EXPECT_CALL(mock, AddTrigger).WillRepeatedly(Return(SOFTBUS_OK));
2223
2224 LaneLinkInfo linkInfo;
2225 linkInfo.type = LANE_WLAN_2P4G;
2226 const LnnLaneManager *laneManager = GetLaneManager();
2227 LaneType laneType = LANE_TYPE_TRANS;
2228 int32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
2229 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
2230
2231 uint64_t laneId = LANE_ID_BASE;
2232 int32_t ret = AddLaneResourceToPool(&linkInfo, laneId, false);
2233 EXPECT_EQ(ret, SOFTBUS_OK);
2234
2235 ret = LaneDetectReliability(laneReqId, &linkInfo, &cb);
2236 EXPECT_EQ(ret, SOFTBUS_OK);
2237
2238 DelLaneResourceByLaneId(laneId, false);
2239 EXPECT_EQ(ret, SOFTBUS_OK);
2240 }
2241
2242 /*
2243 * @tc.name: LANE_DETECT_RELIABILITY_002
2244 * @tc.desc: WLAN LANE DETECT RELIABILITY TEST
2245 * @tc.type: FUNC
2246 * @tc.require:
2247 */
2248 HWTEST_F(LNNLaneMockTest, LANE_DETECT_RELIABILITY_002, TestSize.Level1)
2249 {
2250 NiceMock<LaneDepsInterfaceMock> mock;
2251 int32_t events = 0;
2252 ListenerModule module = LANE;
2253 EXPECT_CALL(mock, StartBaseClient).WillRepeatedly(Return(SOFTBUS_OK));
2254 LaneLinkCb cb = {
2255 .onLaneLinkSuccess = OnLaneLinkSuccess,
2256 .onLaneLinkFail = OnLaneLinkFail,
2257 };
2258
2259 LaneLinkInfo linkInfo;
2260 linkInfo.type = LANE_WLAN_5G;
2261 const LnnLaneManager *laneManager = GetLaneManager();
2262 LaneType laneType = LANE_TYPE_TRANS;
2263 int32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
2264 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
2265
2266 uint64_t laneId = LANE_ID_BASE;
2267 int32_t ret = AddLaneResourceToPool(&linkInfo, laneId, false);
2268 EXPECT_EQ(ret, SOFTBUS_OK);
2269
2270 ret = LaneDetectOnDataEvent(module, events, FD);
2271 EXPECT_EQ(ret, SOFTBUS_LANE_NOT_FOUND);
2272 EXPECT_CALL(mock, ConnOpenClientSocket).WillRepeatedly(Return(SOFTBUS_OK));
2273 EXPECT_CALL(mock, AddTrigger).WillRepeatedly(Return(SOFTBUS_OK));
2274
2275 ret = LaneDetectReliability(laneReqId, &linkInfo, &cb);
2276 EXPECT_EQ(ret, SOFTBUS_OK);
2277
2278 LaneDetectInfo requestItem = {};
2279 if (GetLaneDetectInfoByWlanFd(SOFTBUS_OK, &requestItem) != SOFTBUS_OK) {
2280 return;
2281 }
2282 bool isSendSuc = true;
2283 ret = NotifyWlanDetectResult(&requestItem, isSendSuc);
2284 EXPECT_EQ(ret, SOFTBUS_OK);
2285
2286 ret = LaneDetectReliability(laneReqId, &linkInfo, &cb);
2287 EXPECT_EQ(ret, SOFTBUS_OK);
2288 ret = LaneDetectOnDataEvent(module, events, SOFTBUS_OK);
2289 EXPECT_EQ(ret, SOFTBUS_OK);
2290 ret = LaneDetectReliability(INVALID_LANE_REQ_ID, &linkInfo, &cb);
2291 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2292
2293 ret = DelLaneResourceByLaneId(laneId, false);
2294 EXPECT_EQ(ret, SOFTBUS_OK);
2295 }
2296
2297 /*
2298 * @tc.name: LANE_DETECT_RELIABILITY_003
2299 * @tc.desc: WLAN LANE DETECT RELIABILITY TEST
2300 * @tc.type: FUNC
2301 * @tc.require:
2302 */
2303 HWTEST_F(LNNLaneMockTest, LANE_DETECT_RELIABILITY_003, TestSize.Level1)
2304 {
2305 const char *ipAddr = "127.0.0.1";
2306 NiceMock<LaneDepsInterfaceMock> mock;
2307 EXPECT_CALL(mock, StartBaseClient).WillRepeatedly(Return(SOFTBUS_OK));
2308 LaneLinkCb cb = {
2309 .onLaneLinkSuccess = OnLaneLinkSuccess,
2310 .onLaneLinkFail = OnLaneLinkFail,
2311 };
2312
2313 LaneLinkInfo linkInfo;
2314 linkInfo.type = LANE_WLAN_5G;
2315 linkInfo.linkInfo.wlan.connInfo.port = PORT_A;
2316 if (strcpy_s(linkInfo.linkInfo.wlan.connInfo.addr, MAX_SOCKET_ADDR_LEN, ipAddr) != EOK) {
2317 return;
2318 }
2319 const LnnLaneManager *laneManager = GetLaneManager();
2320 LaneType laneType = LANE_TYPE_TRANS;
2321 int32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
2322 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
2323
2324 uint64_t laneId = LANE_ID_BASE;
2325 int32_t ret = AddLaneResourceToPool(&linkInfo, laneId, false);
2326 EXPECT_EQ(ret, SOFTBUS_OK);
2327
2328 EXPECT_CALL(mock, ConnOpenClientSocket)
2329 .WillOnce(Return(SOFTBUS_TCPCONNECTION_SOCKET_ERR))
2330 .WillRepeatedly(Return(SOFTBUS_OK));
2331 EXPECT_CALL(mock, AddTrigger).WillRepeatedly(Return(SOFTBUS_LANE_DETECT_FAIL));
2332
2333 ret = LaneDetectReliability(laneReqId, &linkInfo, &cb);
2334 EXPECT_EQ(ret, SOFTBUS_TCPCONNECTION_SOCKET_ERR);
2335 linkInfo.linkInfo.wlan.connInfo.port = PORT_B;
2336
2337 ret = LaneDetectReliability(laneReqId, &linkInfo, &cb);
2338 EXPECT_EQ(ret, SOFTBUS_LANE_DETECT_FAIL);
2339 ret = DelLaneResourceByLaneId(laneId, false);
2340 EXPECT_EQ(ret, SOFTBUS_OK);
2341 }
2342
2343 /*
2344 * @tc.name: LANE_DETECT_RELIABILITY_004
2345 * @tc.desc: WLAN LANE DETECT RELIABILITY TEST
2346 * @tc.type: FUNC
2347 * @tc.require:
2348 */
2349 HWTEST_F(LNNLaneMockTest, LANE_DETECT_RELIABILITY_004, TestSize.Level1)
2350 {
2351 const char *ipAddr = "127.0.0.1";
2352 LaneLinkCb cb = {
2353 .onLaneLinkSuccess = OnLaneLinkSuccessForDetect,
2354 .onLaneLinkFail = OnLaneLinkFailForDetect,
2355 };
2356
2357 LaneLinkInfo linkInfo;
2358 linkInfo.type = LANE_WLAN_5G;
2359 linkInfo.linkInfo.wlan.connInfo.port = PORT_A;
2360 EXPECT_EQ(strcpy_s(linkInfo.linkInfo.wlan.connInfo.addr, MAX_SOCKET_ADDR_LEN, ipAddr), EOK);
2361 const LnnLaneManager *laneManager = GetLaneManager();
2362 LaneType laneType = LANE_TYPE_TRANS;
2363 int32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
2364 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
2365
2366 NiceMock<LaneDepsInterfaceMock> mock;
2367 EXPECT_CALL(mock, ConnOpenClientSocket)
2368 .WillOnce(Return(SOFTBUS_TCPCONNECTION_SOCKET_ERR))
2369 .WillRepeatedly(Return(SOFTBUS_OK));
2370 EXPECT_CALL(mock, AddTrigger).WillOnce(Return(SOFTBUS_CONN_FAIL))
2371 .WillRepeatedly(LaneDepsInterfaceMock::ActionOfAddTrigger);
2372 char buf[] = "lanedetect";
2373 EXPECT_CALL(mock, ConnSendSocketData).WillRepeatedly(Return(sizeof(buf)));
2374
2375 int32_t ret = LaneDetectReliability(laneReqId, &linkInfo, &cb);
2376 EXPECT_EQ(ret, SOFTBUS_TCPCONNECTION_SOCKET_ERR);
2377
2378 ret = LaneDetectReliability(laneReqId, &linkInfo, &cb);
2379 EXPECT_EQ(ret, SOFTBUS_CONN_FAIL);
2380
2381 ret = LaneDetectReliability(laneReqId, &linkInfo, &cb);
2382 EXPECT_EQ(ret, SOFTBUS_OK);
2383 }
2384
2385 /*
2386 * @tc.name: LANE_INIT_RELIABLITY_001
2387 * @tc.desc: LANE INIT RELIABLITY TEST
2388 * @tc.type: FUNC
2389 * @tc.require:
2390 */
2391 HWTEST_F(LNNLaneMockTest, LANE_INIT_RELIABLITY_001, TestSize.Level1)
2392 {
2393 NiceMock<LaneDepsInterfaceMock> mock;
2394 EXPECT_CALL(mock, StartBaseClient).WillRepeatedly(Return(SOFTBUS_OK));
2395 int32_t ret = InitLaneReliability();
2396 EXPECT_EQ(ret, SOFTBUS_OK);
2397 }
2398
2399 /*
2400 * @tc.name: LANE_DEL_AND_ADD_LANERESOURCEITEM_001
2401 * @tc.desc: LANE_DEL AND ADD LANERESOURCEITEM CLIENT
2402 * @tc.type: FUNC
2403 * @tc.require:
2404 */
2405 HWTEST_F(LNNLaneMockTest, LANE_DEL_AND_ADD_LANERESOURCEITEM_001, TestSize.Level1)
2406 {
2407 NiceMock<LaneDepsInterfaceMock> mock;
2408 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
2409 LaneLinkInfo linkInfo;
2410 ASSERT_EQ(memset_s(&linkInfo, sizeof(LaneLinkInfo), 0, sizeof(LaneLinkInfo)), EOK);
2411 linkInfo.type = LANE_HML;
2412 ASSERT_EQ(strncpy_s(linkInfo.linkInfo.p2p.connInfo.peerIp, IP_LEN, PEER_IP_HML, strlen(PEER_IP_HML)), EOK);
2413 ASSERT_EQ(strncpy_s(linkInfo.peerUdid, UDID_BUF_LEN, PEER_UDID, strlen(PEER_UDID)), EOK);
2414
2415 uint64_t laneId = INVALID_LANE_ID;
2416 int32_t ret = AddLaneResourceToPool(nullptr, laneId, false);
2417 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2418 ret = AddLaneResourceToPool(&linkInfo, INVALID_LANE_ID, false);
2419 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2420
2421 laneId = LANE_ID_BASE;
2422 uint32_t clientRef = 0;
2423 ret = AddLaneResourceToPool(&linkInfo, laneId, false);
2424 EXPECT_EQ(ret, SOFTBUS_OK);
2425 clientRef++;
2426 ret = AddLaneResourceToPool(&linkInfo, laneId, false);
2427 EXPECT_EQ(ret, SOFTBUS_OK);
2428 clientRef++;
2429
2430 LaneResource laneResourse;
2431 ASSERT_EQ(memset_s(&laneResourse, sizeof(LaneResource), 0, sizeof(LaneResource)), EOK);
2432 ret = FindLaneResourceByLaneId(laneId, &laneResourse);
2433 EXPECT_EQ(ret, SOFTBUS_OK);
2434 EXPECT_FALSE(laneResourse.isServerSide);
2435 EXPECT_EQ(laneResourse.clientRef, clientRef);
2436
2437 ret = DelLaneResourceByLaneId(INVALID_LANE_ID, false);
2438 EXPECT_EQ(ret, SOFTBUS_LANE_RESOURCE_NOT_FOUND);
2439 ret = FindLaneResourceByLaneId(laneId, &laneResourse);
2440 EXPECT_EQ(laneResourse.clientRef, clientRef);
2441
2442 ret = DelLaneResourceByLaneId(laneId, false);
2443 EXPECT_EQ(ret, SOFTBUS_OK);
2444 clientRef--;
2445 ret = FindLaneResourceByLaneId(laneId, &laneResourse);
2446 EXPECT_EQ(laneResourse.clientRef, clientRef);
2447
2448 ret = DelLaneResourceByLaneId(laneId, false);
2449 EXPECT_EQ(ret, SOFTBUS_OK);
2450 ret = FindLaneResourceByLaneId(laneId, &laneResourse);
2451 EXPECT_EQ(ret, SOFTBUS_LANE_RESOURCE_NOT_FOUND);
2452 }
2453
2454 /*
2455 * @tc.name: LANE_DEL_AND_ADD_LANERESOURCEITEM_002
2456 * @tc.desc: LANE_DEL AND ADD LANERESOURCEITEM SERVER
2457 * @tc.type: FUNC
2458 * @tc.require:
2459 */
2460 HWTEST_F(LNNLaneMockTest, LANE_DEL_AND_ADD_LANERESOURCEITEM_002, TestSize.Level1)
2461 {
2462 NiceMock<LaneDepsInterfaceMock> mock;
2463 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
2464 LaneLinkInfo linkInfo;
2465 ASSERT_EQ(memset_s(&linkInfo, sizeof(LaneLinkInfo), 0, sizeof(LaneLinkInfo)), EOK);
2466 linkInfo.type = LANE_HML;
2467 ASSERT_EQ(strncpy_s(linkInfo.linkInfo.p2p.connInfo.peerIp, IP_LEN, PEER_IP_HML, strlen(PEER_IP_HML)), EOK);
2468 ASSERT_EQ(strncpy_s(linkInfo.peerUdid, UDID_BUF_LEN, PEER_UDID, strlen(PEER_UDID)), EOK);
2469
2470 uint64_t laneId = INVALID_LANE_ID;
2471 int32_t ret = AddLaneResourceToPool(nullptr, laneId, true);
2472 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2473
2474 ret = AddLaneResourceToPool(&linkInfo, laneId, true);
2475 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2476
2477 laneId = LANE_ID_BASE;
2478 uint32_t serverRef = 0;
2479 ret = AddLaneResourceToPool(&linkInfo, laneId, true);
2480 EXPECT_EQ(ret, SOFTBUS_OK);
2481
2482 ret = AddLaneResourceToPool(&linkInfo, laneId, true);
2483 EXPECT_EQ(ret, SOFTBUS_LANE_TRIGGER_LINK_FAIL);
2484
2485 LaneResource laneResourse;
2486 ASSERT_EQ(memset_s(&laneResourse, sizeof(LaneResource), 0, sizeof(LaneResource)), EOK);
2487 ret = FindLaneResourceByLaneId(laneId, &laneResourse);
2488 EXPECT_EQ(ret, SOFTBUS_OK);
2489 EXPECT_TRUE(laneResourse.isServerSide);
2490 EXPECT_EQ(laneResourse.clientRef, serverRef);
2491
2492 ret = DelLaneResourceByLaneId(laneId, false);
2493 EXPECT_EQ(ret, SOFTBUS_OK);
2494
2495 ret = FindLaneResourceByLaneId(laneId, &laneResourse);
2496 EXPECT_EQ(ret, SOFTBUS_OK);
2497
2498 ret = DelLaneResourceByLaneId(laneId, true);
2499 EXPECT_EQ(ret, SOFTBUS_OK);
2500 }
2501
2502 /*
2503 * @tc.name: LANE_GENERATE_LANE_ID_001
2504 * @tc.desc: LANE GENERATE LANE ID
2505 * @tc.type: FUNC
2506 * @tc.require:
2507 */
2508 HWTEST_F(LNNLaneMockTest, LANE_GENERATE_LANE_ID_001, TestSize.Level1)
2509 {
2510 NiceMock<LaneDepsInterfaceMock> laneMock;
2511 EXPECT_CALL(laneMock, SoftBusGenerateStrHash)
2512 .WillOnce(Return(SOFTBUS_ENCRYPT_ERR))
2513 .WillRepeatedly(LaneDepsInterfaceMock::ActionOfGenerateStrHash);
2514
2515 uint64_t laneId = GenerateLaneId(LOCAL_UDID, PEER_UDID, LANE_HML);
2516 EXPECT_EQ(laneId, INVALID_LANE_ID);
2517
2518 laneId = GenerateLaneId(LOCAL_UDID, PEER_UDID, LANE_HML);
2519 EXPECT_NE(laneId, INVALID_LANE_ID);
2520 }
2521
2522 /*
2523 * @tc.name: LNN_SELECT_AUTH_LANE_TEST_001
2524 * @tc.desc: SelectAuthLane
2525 * @tc.type: FUNC
2526 * @tc.require:
2527 */
2528 HWTEST_F(LNNLaneMockTest, LNN_SELECT_AUTH_LANE_TEST_001, TestSize.Level1)
2529 {
2530 const char *networkId = "testnetworkid123";
2531 NiceMock<LaneDepsInterfaceMock> mock;
2532 LanePreferredLinkList recommendList = {};
2533 LanePreferredLinkList request = {};
2534
2535 request.linkTypeNum = 4;
2536 request.linkType[0] = LANE_P2P;
2537 request.linkType[1] = LANE_BLE;
2538 request.linkType[2] = LANE_BR;
2539 request.linkType[3] = LANE_HML;
2540
2541 EXPECT_CALL(mock, LnnGetLocalNumInfo)
2542 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(1), Return(SOFTBUS_OK)));
2543 EXPECT_CALL(mock, LnnGetRemoteNumInfo)
2544 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(1), Return(SOFTBUS_OK)));
2545 int32_t ret = SelectAuthLane(nullptr, &recommendList, &request);
2546 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2547
2548 ret = SelectAuthLane(networkId, nullptr, &request);
2549 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2550
2551 ret = SelectAuthLane(networkId, &recommendList, nullptr);
2552 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2553
2554 ret = SelectAuthLane(networkId, &recommendList, &request);
2555 EXPECT_EQ(ret, SOFTBUS_LANE_NO_AVAILABLE_LINK);
2556 }
2557
2558 /*
2559 * @tc.name: LNN_AUTH_ALLOC_TEST_001
2560 * @tc.desc: AuthAlloc
2561 * @tc.type: FUNC
2562 * @tc.require:
2563 */
2564 HWTEST_F(LNNLaneMockTest, LNN_AUTH_ALLOC_TEST_001, TestSize.Level1)
2565 {
2566 const LnnLaneManager *laneManager = GetLaneManager();
2567 LaneType laneType = LANE_TYPE_CTRL;
2568 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
2569 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
2570
2571 NiceMock<LaneDepsInterfaceMock> mock;
2572 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
2573 EXPECT_CALL(mock, LnnGetLocalNumInfo)
2574 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(16), Return(SOFTBUS_OK)));
2575 EXPECT_CALL(mock, LnnGetRemoteNumInfo)
2576 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(16), Return(SOFTBUS_OK)));
2577 EXPECT_CALL(mock, LnnGetLocalNumU32Info)
2578 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(16), Return(SOFTBUS_OK)));
2579 EXPECT_CALL(mock, LnnGetRemoteNumU32Info)
2580 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(16), Return(SOFTBUS_OK)));
2581
2582 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
2583 wifiMock.SetDefaultResult();
2584
2585 LaneAllocInfo allocInfo = {};
2586 allocInfo.type = laneType;
2587 (void)strncpy_s(allocInfo.networkId, NETWORK_ID_BUF_LEN,
2588 NODE_NETWORK_ID, strlen(NODE_NETWORK_ID));
2589 allocInfo.transType = LANE_T_BYTE;
2590 allocInfo.qosRequire.minBW = 0;
2591 allocInfo.qosRequire.maxLaneLatency = 0;
2592 allocInfo.qosRequire.minLaneLatency = 0;
2593
2594 int32_t ret = laneManager->lnnAllocLane(laneReqId, nullptr, &g_listener);
2595 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2596
2597 ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, nullptr);
2598 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2599
2600 ret = laneManager->lnnAllocLane(INVALID_LANE_REQ_ID, &allocInfo, &g_listener);
2601 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2602
2603 AuthLinkTypeList mockList = {};
2604 mockList.linkType[0] = AUTH_LINK_TYPE_WIFI;
2605 mockList.linkTypeNum = 1;
2606 EXPECT_CALL(mock, GetAuthLinkTypeList)
2607 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(mockList), Return(SOFTBUS_OK)));
2608 ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listener);
2609 EXPECT_EQ(ret, SOFTBUS_LANE_GET_LEDGER_INFO_ERR);
2610 }
2611
2612 /*
2613 * @tc.name: LANE_CLEAR_LANE_RESOURCE_BYLANEID_001
2614 * @tc.desc: ClearLaneResourceByLaneId
2615 * @tc.type: FUNC
2616 * @tc.require:
2617 */
2618 HWTEST_F(LNNLaneMockTest, LANE_CLEAR_LANE_RESOURCE_BYLANEID_001, TestSize.Level1)
2619 {
2620 NiceMock<LaneDepsInterfaceMock> mock;
2621 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
2622
2623 uint64_t laneId = LANE_ID_BASE;
2624 int32_t ret = ClearLaneResourceByLaneId(laneId);
2625 EXPECT_EQ(ret, SOFTBUS_LANE_RESOURCE_NOT_FOUND);
2626
2627 LaneLinkInfo linkInfo = {};
2628 linkInfo.type = LANE_HML;
2629 EXPECT_EQ(strncpy_s(linkInfo.linkInfo.p2p.connInfo.peerIp, IP_LEN, PEER_IP_HML, strlen(PEER_IP_HML)), EOK);
2630 EXPECT_EQ(strncpy_s(linkInfo.peerUdid, UDID_BUF_LEN, PEER_UDID, strlen(PEER_UDID)), EOK);
2631 uint32_t clientRef = 0;
2632 ret = AddLaneResourceToPool(&linkInfo, laneId, true);
2633 EXPECT_EQ(ret, SOFTBUS_OK);
2634
2635 LaneResource laneResourse = {};
2636 ret = FindLaneResourceByLaneId(laneId, &laneResourse);
2637 EXPECT_EQ(ret, SOFTBUS_OK);
2638 EXPECT_TRUE(laneResourse.isServerSide);
2639 EXPECT_EQ(laneResourse.clientRef, clientRef);
2640
2641 ret = ClearLaneResourceByLaneId(laneId);
2642 EXPECT_EQ(ret, SOFTBUS_OK);
2643
2644 ret = FindLaneResourceByLaneId(laneId, &laneResourse);
2645 EXPECT_EQ(ret, SOFTBUS_LANE_RESOURCE_NOT_FOUND);
2646 }
2647
2648 /*
2649 * @tc.name: LANE_PPOCESS_VAP_INFO_001
2650 * @tc.desc: ProcessVapInfo hml
2651 * @tc.type: FUNC
2652 * @tc.require:
2653 */
2654 HWTEST_F(LNNLaneMockTest, LANE_PPOCESS_VAP_INFO_001, TestSize.Level1)
2655 {
2656 NiceMock<LaneDepsInterfaceMock> mock;
2657 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
2658 LaneLinkInfo linkInfo = {};
2659 linkInfo.type = LANE_P2P;
2660 EXPECT_EQ(strncpy_s(linkInfo.linkInfo.p2p.connInfo.peerIp, IP_LEN, PEER_IP_HML, strlen(PEER_IP_HML)), EOK);
2661 EXPECT_EQ(strncpy_s(linkInfo.peerUdid, UDID_BUF_LEN, PEER_UDID, strlen(PEER_UDID)), EOK);
2662 uint64_t laneId = LANE_ID_BASE;
2663 uint64_t laneIdExt = LANE_ID_BASE + 1;
2664 uint32_t clientRef = 0;
2665 int32_t ret = AddLaneResourceToPool(&linkInfo, laneId, true);
2666 EXPECT_EQ(ret, SOFTBUS_OK);
2667
2668 linkInfo.type = LANE_HML;
2669 ret = AddLaneResourceToPool(&linkInfo, laneIdExt, false);
2670 EXPECT_EQ(ret, SOFTBUS_OK);
2671 clientRef++;
2672
2673 ret = ClearLaneResourceByLaneId(laneId);
2674 EXPECT_EQ(ret, SOFTBUS_OK);
2675
2676 LaneResource laneResourse = {};
2677 ret = FindLaneResourceByLaneId(laneId, &laneResourse);
2678 EXPECT_EQ(ret, SOFTBUS_LANE_RESOURCE_NOT_FOUND);
2679
2680 ret = FindLaneResourceByLaneId(laneIdExt, &laneResourse);
2681 EXPECT_EQ(ret, SOFTBUS_OK);
2682 EXPECT_TRUE(!laneResourse.isServerSide);
2683 EXPECT_EQ(laneResourse.clientRef, clientRef);
2684
2685 ret = DelLaneResourceByLaneId(laneIdExt, false);
2686 EXPECT_EQ(ret, SOFTBUS_OK);
2687 }
2688
2689 /*
2690 * @tc.name: LANE_PPOCESS_VAP_INFO_002
2691 * @tc.desc: ProcessVapInfo p2p
2692 * @tc.type: FUNC
2693 * @tc.require:
2694 */
2695 HWTEST_F(LNNLaneMockTest, LANE_PPOCESS_VAP_INFO_002, TestSize.Level1)
2696 {
2697 NiceMock<LaneDepsInterfaceMock> mock;
2698 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
2699 LaneLinkInfo linkInfo = {};
2700 linkInfo.type = LANE_HML;
2701 EXPECT_EQ(strncpy_s(linkInfo.linkInfo.p2p.connInfo.peerIp, IP_LEN, PEER_IP_HML, strlen(PEER_IP_HML)), EOK);
2702 EXPECT_EQ(strncpy_s(linkInfo.peerUdid, UDID_BUF_LEN, PEER_UDID, strlen(PEER_UDID)), EOK);
2703 uint64_t laneId = LANE_ID_BASE;
2704 uint64_t laneIdExt = LANE_ID_BASE + 1;
2705 uint32_t clientRef = 0;
2706 int32_t ret = AddLaneResourceToPool(&linkInfo, laneId, true);
2707 EXPECT_EQ(ret, SOFTBUS_OK);
2708
2709 linkInfo.type = LANE_P2P;
2710 ret = AddLaneResourceToPool(&linkInfo, laneIdExt, false);
2711 EXPECT_EQ(ret, SOFTBUS_OK);
2712 clientRef++;
2713
2714 ret = ClearLaneResourceByLaneId(laneId);
2715 EXPECT_EQ(ret, SOFTBUS_OK);
2716
2717 LaneResource laneResourse = {};
2718 ret = FindLaneResourceByLaneId(laneId, &laneResourse);
2719 EXPECT_EQ(ret, SOFTBUS_LANE_RESOURCE_NOT_FOUND);
2720
2721 ret = FindLaneResourceByLaneId(laneIdExt, &laneResourse);
2722 EXPECT_EQ(ret, SOFTBUS_OK);
2723 EXPECT_TRUE(!laneResourse.isServerSide);
2724 EXPECT_EQ(laneResourse.clientRef, clientRef);
2725
2726 ret = DelLaneResourceByLaneId(laneIdExt, false);
2727 EXPECT_EQ(ret, SOFTBUS_OK);
2728 }
2729
2730 /*
2731 * @tc.name: LNN_LANE_SELECT_01
2732 * @tc.desc: SelectLane
2733 * @tc.type: FUNC
2734 * @tc.require:
2735 */
2736 HWTEST_F(LNNLaneMockTest, LNN_LANE_SELECT_01, TestSize.Level1)
2737 {
2738 const char *networkId = "test";
2739 LaneLinkType linkType = LANE_LINK_TYPE_BUTT;
2740 int32_t ret = LaneCapCheck(networkId, linkType);
2741 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2742 }
2743
2744 /*
2745 * @tc.name: LNN_LANE_SELECT_02
2746 * @tc.desc: SelectLane
2747 * @tc.type: FUNC
2748 * @tc.require:
2749 */
2750 HWTEST_F(LNNLaneMockTest, LNN_LANE_SELECT_02, TestSize.Level1)
2751 {
2752 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
2753 NiceMock<LaneDepsInterfaceMock> mock;
2754
2755 EXPECT_CALL(wifiMock, SoftBusGetWifiState)
2756 .WillRepeatedly(Return(SOFTBUS_WIFI_STATE_INACTIVE));
2757 int32_t ret = GetErrCodeOfLink("networkId", LANE_WLAN_2P4G);
2758 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_OFF);
2759
2760 ret = GetErrCodeOfLink("networkId", LANE_P2P_REUSE);
2761 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_OFF);
2762
2763 ret = GetErrCodeOfLink("networkId", LANE_HML);
2764 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_OFF);
2765
2766 EXPECT_CALL(wifiMock, SoftBusGetWifiState)
2767 .WillRepeatedly(Return(SOFTBUS_WIFI_STATE_DEACTIVATING));
2768 ret = GetErrCodeOfLink("networkId", LANE_HML);
2769 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_OFF);
2770
2771 ret = GetErrCodeOfLink("networkId", LANE_P2P_REUSE);
2772 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_OFF);
2773
2774 EXPECT_CALL(mock, SoftBusGetBtState)
2775 .WillRepeatedly(Return(0));
2776 EXPECT_EQ(GetErrCodeOfLink("networkId", LANE_BR), SOFTBUS_LANE_BT_OFF);
2777 EXPECT_EQ(GetErrCodeOfLink("networkId", LANE_BLE), SOFTBUS_LANE_BT_OFF);
2778 EXPECT_EQ(GetErrCodeOfLink("networkId", LANE_BLE_DIRECT), SOFTBUS_LANE_BT_OFF);
2779 EXPECT_EQ(GetErrCodeOfLink("networkId", LANE_BLE_REUSE), SOFTBUS_LANE_BT_OFF);
2780
2781 EXPECT_CALL(mock, SoftBusGetBtState)
2782 .WillRepeatedly(Return(1));
2783 EXPECT_EQ(GetErrCodeOfLink("networkId", LANE_BR), SOFTBUS_LANE_LOCAL_NO_BR_CAP);
2784 EXPECT_EQ(GetErrCodeOfLink("networkId", LANE_BLE), SOFTBUS_LANE_LOCAL_NO_BLE_CAP);
2785 EXPECT_EQ(GetErrCodeOfLink("networkId", LANE_BLE_DIRECT), SOFTBUS_LANE_LOCAL_NO_BLE_CAP);
2786 }
2787
2788 /*
2789 * @tc.name: LNN_LANE_SELECT_RULE_01
2790 * @tc.desc: SelectLaneRule
2791 * @tc.type: FUNC
2792 * @tc.require:
2793 */
2794 HWTEST_F(LNNLaneMockTest, LNN_LANE_SELECT_RULE_01, TestSize.Level1)
2795 {
2796 LaneLinkType linkList;
2797 uint32_t listNum = 0;
2798 LanePreferredLinkList recommendList;
2799 int32_t ret = FinalDecideLinkType(nullptr, &linkList, listNum, &recommendList);
2800 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2801
2802 ret = FinalDecideLinkType(nullptr, nullptr, listNum, &recommendList);
2803 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2804
2805 ret = FinalDecideLinkType(nullptr, nullptr, listNum, nullptr);
2806 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2807
2808 listNum = LANE_LINK_TYPE_BUTT;
2809 ret = FinalDecideLinkType("test", &linkList, listNum, &recommendList);
2810 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2811 }
2812
2813 /*
2814 * @tc.name: LNN_LANE_SELECT_RULE_02
2815 * @tc.desc: SelectLaneRule
2816 * @tc.type: FUNC
2817 * @tc.require:
2818 */
2819 HWTEST_F(LNNLaneMockTest, LNN_LANE_SELECT_RULE_02, TestSize.Level1)
2820 {
2821 LaneLinkType linkList[LANE_LINK_TYPE_BUTT];
2822 uint32_t listNum = 1;
2823 LanePreferredLinkList recommendList;
2824
2825 NiceMock<LaneDepsInterfaceMock> linkMock;
2826 EXPECT_CALL(linkMock, LnnGetLocalNumU64Info)
2827 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(1), Return(SOFTBUS_OK)));
2828 EXPECT_CALL(linkMock, LnnGetRemoteNumU64Info)
2829 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(1), Return(SOFTBUS_OK)));
2830
2831 linkList[0] = LANE_P2P;
2832 int32_t ret = FinalDecideLinkType("test", linkList, listNum, &recommendList);
2833 EXPECT_EQ(ret, SOFTBUS_OK);
2834 }
2835
2836 /*
2837 * @tc.name: LNN_LANE_SELECT_RULE_03
2838 * @tc.desc: SelectLaneRule
2839 * @tc.type: FUNC
2840 * @tc.require:
2841 */
2842 HWTEST_F(LNNLaneMockTest, LNN_LANE_SELECT_RULE_03, TestSize.Level1)
2843 {
2844 LaneLinkType linkList;
2845 uint32_t listNum = 1;
2846 LanePreferredLinkList recommendList;
2847
2848 NiceMock<LaneDepsInterfaceMock> linkMock;
2849 EXPECT_CALL(linkMock, LnnGetLocalNumU64Info)
2850 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(1), Return(SOFTBUS_ERR)));
2851
2852 int32_t ret = FinalDecideLinkType("test", &linkList, listNum, &recommendList);
2853 EXPECT_EQ(ret, SOFTBUS_OK);
2854
2855 EXPECT_CALL(linkMock, LnnGetLocalNumU64Info)
2856 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(-1), Return(SOFTBUS_OK)));
2857 ret = FinalDecideLinkType("test", &linkList, listNum, &recommendList);
2858 EXPECT_EQ(ret, SOFTBUS_OK);
2859
2860 EXPECT_CALL(linkMock, LnnGetLocalNumU64Info)
2861 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(1), Return(SOFTBUS_OK)));
2862 EXPECT_CALL(linkMock, LnnGetRemoteNumU64Info)
2863 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(1), Return(SOFTBUS_ERR)));
2864 ret = FinalDecideLinkType("test", &linkList, listNum, &recommendList);
2865 EXPECT_EQ(ret, SOFTBUS_OK);
2866
2867 EXPECT_CALL(linkMock, LnnGetRemoteNumU64Info)
2868 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(-1), Return(SOFTBUS_OK)));
2869 ret = FinalDecideLinkType("test", &linkList, listNum, &recommendList);
2870 EXPECT_EQ(ret, SOFTBUS_OK);
2871 }
2872
2873 /*
2874 * @tc.name: LNN_LANE_SELECT_RULE_04
2875 * @tc.desc: SelectLaneRule
2876 * @tc.type: FUNC
2877 * @tc.require:
2878 */
2879 HWTEST_F(LNNLaneMockTest, LNN_LANE_SELECT_RULE_04, TestSize.Level1)
2880 {
2881 LaneSelectParam request;
2882 LanePreferredLinkList recommendList;
2883 int32_t ret = DecideAvailableLane("test", nullptr, &recommendList);
2884 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2885
2886 ret = DecideAvailableLane("test", &request, nullptr);
2887 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2888
2889 ret = DecideAvailableLane("test", nullptr, nullptr);
2890 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2891 }
2892
2893 /*
2894 * @tc.name: LNN_LANE_SELECT_RULE_05
2895 * @tc.desc: SelectLaneRule
2896 * @tc.type: FUNC
2897 * @tc.require:
2898 */
2899 HWTEST_F(LNNLaneMockTest, LNN_LANE_SELECT_RULE_05, TestSize.Level1)
2900 {
2901 NiceMock<LaneDepsInterfaceMock> linkMock;
2902
2903 LnnWifiAdpterInterfaceMock wifiMock;
2904 LaneSelectParam request;
2905 LanePreferredLinkList recommendList;
2906
2907 request.qosRequire.minLaneLatency = 0;
2908 EXPECT_CALL(linkMock, LnnGetRemoteNodeInfoById)
2909 .WillRepeatedly(Return(SOFTBUS_OK));
2910 EXPECT_CALL(linkMock, LnnGetLocalNumU32Info)
2911 .WillRepeatedly(Return(SOFTBUS_ERR));
2912 EXPECT_CALL(wifiMock, SoftBusGetWifiState)
2913 .WillRepeatedly(Return(SOFTBUS_WIFI_STATE_INACTIVE));
2914 int32_t ret = DecideAvailableLane("test", &request, &recommendList);
2915 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_OFF);
2916
2917 request.transType = LANE_T_FILE;
2918 request.qosRequire.minBW = DEFAULT_QOSINFO_MIN_BW;
2919 request.qosRequire.maxLaneLatency = DEFAULT_QOSINFO_MAX_LATENCY;
2920 request.qosRequire.minLaneLatency = DEFAULT_QOSINFO_MIN_LATENCY;
2921
2922 EXPECT_CALL(linkMock, LnnGetRemoteStrInfo)
2923 .WillRepeatedly(Return(SOFTBUS_ERR));
2924 ret = DecideAvailableLane(NODE_NETWORK_ID, &request, &recommendList);
2925 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_OFF);
2926
2927 EXPECT_CALL(linkMock, LnnGetOsTypeByNetworkId)
2928 .WillRepeatedly(Return(SOFTBUS_ERR));
2929 ret = DecideAvailableLane(NODE_NETWORK_ID, &request, &recommendList);
2930 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_OFF);
2931
2932 int32_t osType = OH_OS_TYPE;
2933 EXPECT_CALL(linkMock, LnnGetOsTypeByNetworkId)
2934 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(osType), Return(SOFTBUS_OK)));
2935 ret = DecideAvailableLane(NODE_NETWORK_ID, &request, &recommendList);
2936 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_OFF);
2937
2938 EXPECT_CALL(linkMock, LnnGetLocalNumU64Info)
2939 .WillRepeatedly(Return(SOFTBUS_ERR));
2940 EXPECT_CALL(linkMock, LnnGetOsTypeByNetworkId)
2941 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(osType), Return(SOFTBUS_OK)));
2942 ret = DecideAvailableLane(NODE_NETWORK_ID, &request, &recommendList);
2943 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_OFF);
2944 }
2945
2946 /*
2947 * @tc.name: LNN_LANE_01
2948 * @tc.desc: SelectLaneRule
2949 * @tc.type: FUNC
2950 * @tc.require:
2951 */
2952 HWTEST_F(LNNLaneMockTest, LNN_LANE_01, TestSize.Level1)
2953 {
2954 ILaneIdStateListener listener;
2955 RegisterLaneIdListener(nullptr);
2956
2957 listener.OnLaneIdEnabled = nullptr;
2958 listener.OnLaneIdDisabled = nullptr;
2959 RegisterLaneIdListener(&listener);
2960 UnregisterLaneIdListener(nullptr);
2961 }
2962
2963 /*
2964 * @tc.name: LNN_LANE_02
2965 * @tc.desc: SelectLaneRule
2966 * @tc.type: FUNC
2967 * @tc.require:
2968 */
2969 HWTEST_F(LNNLaneMockTest, LNN_LANE_02, TestSize.Level1)
2970 {
2971 uint32_t laneReqId = 0;
2972 FreeLaneReqId(laneReqId);
2973 laneReqId = 0xfffffff;
2974 FreeLaneReqId(laneReqId);
2975 }
2976
2977 /*
2978 * @tc.name: LNN_LANE_03
2979 * @tc.desc: SelectLaneRule
2980 * @tc.type: FUNC
2981 * @tc.require:
2982 */
2983 HWTEST_F(LNNLaneMockTest, LNN_LANE_03, TestSize.Level1)
2984 {
2985 LaneRequestOption request;
2986 ILaneListener listener;
2987 request.type = LANE_TYPE_BUTT;
2988 int32_t ret = LnnRequestLane(0, &request, &listener);
2989 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2990
2991 request.type = (LaneType)-1;
2992 ret = LnnRequestLane(0, &request, &listener);
2993 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2994 }
2995
2996 /*
2997 * @tc.name: LNN_LANE_04
2998 * @tc.desc: SelectLaneRule
2999 * @tc.type: FUNC
3000 * @tc.require:
3001 */
3002 HWTEST_F(LNNLaneMockTest, LNN_LANE_04, TestSize.Level1)
3003 {
3004 RawLaneAllocInfo allocInfo;
3005 LaneAllocListener listener;
3006
3007 const LnnLaneManager *laneManager = GetLaneManager();
3008 LaneType laneType = LANE_TYPE_TRANS;
3009 uint32_t laneHandle = laneManager->lnnGetLaneHandle(laneType);
3010 EXPECT_TRUE(laneHandle != INVALID_LANE_REQ_ID);
3011
3012 int32_t ret = laneManager->lnnAllocRawLane(laneHandle, nullptr, &listener);
3013 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
3014 ret = laneManager->lnnAllocRawLane(laneHandle, &allocInfo, nullptr);
3015 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
3016 ret = laneManager->lnnAllocRawLane(laneHandle, nullptr, nullptr);
3017 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
3018
3019 allocInfo.type = LANE_TYPE_BUTT;
3020 ret = laneManager->lnnAllocRawLane(laneHandle, &allocInfo, &listener);
3021 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
3022
3023 allocInfo.type = (LaneType)-1;
3024 ret = laneManager->lnnAllocRawLane(laneHandle, &allocInfo, &listener);
3025 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
3026 }
3027
3028 /*
3029 * @tc.name: LNN_LANE_05
3030 * @tc.desc: SelectLaneRule
3031 * @tc.type: FUNC
3032 * @tc.require:
3033 */
3034 HWTEST_F(LNNLaneMockTest, LNN_LANE_05, TestSize.Level1)
3035 {
3036 NiceMock<LaneDepsInterfaceMock> laneDepMock;
3037 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
3038 const LnnLaneManager *laneManager = GetLaneManager();
3039 LaneType laneType = LANE_TYPE_TRANS;
3040 uint32_t laneHandle = laneManager->lnnGetLaneHandle(laneType);
3041 EXPECT_TRUE(laneHandle != INVALID_LANE_REQ_ID);
3042
3043 EXPECT_CALL(wifiMock, LnnConnectP2p).WillRepeatedly(Return(SOFTBUS_OK));
3044 RawLaneAllocInfo allocInfo;
3045 allocInfo.type = LANE_TYPE_HDLC;
3046 LaneAllocListener listener;
3047 int32_t ret = laneManager->lnnAllocRawLane(laneHandle, &allocInfo, &listener);
3048 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
3049
3050 ret = laneManager->lnnFreeLane(laneHandle);
3051 EXPECT_EQ(ret, SOFTBUS_LANE_NOT_FOUND);
3052 std::this_thread::sleep_for(std::chrono::milliseconds(100));
3053 }
3054
3055 /*
3056 * @tc.name: LNN_LANE_06
3057 * @tc.desc: SelectLaneRule
3058 * @tc.type: FUNC
3059 * @tc.require:
3060 */
3061 HWTEST_F(LNNLaneMockTest, LNN_LANE_06, TestSize.Level1)
3062 {
3063 NiceMock<LaneDepsInterfaceMock> laneDepMock;
3064 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
3065 const LnnLaneManager *laneManager = GetLaneManager();
3066 LaneType laneType = LANE_TYPE_TRANS;
3067 uint32_t laneHandle = laneManager->lnnGetLaneHandle(laneType);
3068 EXPECT_TRUE(laneHandle != INVALID_LANE_REQ_ID);
3069
3070 EXPECT_CALL(wifiMock, LnnConnectP2p).WillRepeatedly(Return(SOFTBUS_OK));
3071 RawLaneAllocInfo allocInfo;
3072 allocInfo.type = LANE_TYPE_TRANS;
3073 LaneAllocListener listener;
3074 int32_t ret = laneManager->lnnAllocRawLane(laneHandle, &allocInfo, &listener);
3075 EXPECT_EQ(ret, SOFTBUS_OK);
3076
3077 ret = laneManager->lnnFreeLane(laneHandle);
3078 EXPECT_EQ(ret, SOFTBUS_OK);
3079 std::this_thread::sleep_for(std::chrono::milliseconds(100));
3080 }
3081
3082 /*
3083 * @tc.name: LNN_LANE_07
3084 * @tc.desc: SelectLaneRule
3085 * @tc.type: FUNC
3086 * @tc.require:
3087 */
3088 HWTEST_F(LNNLaneMockTest, LNN_LANE_07, TestSize.Level1)
3089 {
3090 LaneAllocInfoExt allocInfo;
3091 LaneAllocListener listener;
3092 NiceMock<LaneDepsInterfaceMock> laneDepMock;
3093
3094 const LnnLaneManager *laneManager = GetLaneManager();
3095 LaneType laneType = LANE_TYPE_TRANS;
3096 uint32_t laneHandle = laneManager->lnnGetLaneHandle(laneType);
3097 EXPECT_TRUE(laneHandle != INVALID_LANE_REQ_ID);
3098
3099 int32_t ret = laneManager->lnnAllocTargetLane(laneHandle, &allocInfo, nullptr);
3100 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
3101 ret = laneManager->lnnAllocTargetLane(laneHandle, nullptr, &listener);
3102 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
3103 ret = laneManager->lnnAllocTargetLane(laneHandle, nullptr, nullptr);
3104 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
3105 ret = laneManager->lnnAllocTargetLane(INVALID_LANE_REQ_ID, nullptr, nullptr);
3106 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
3107 ret = laneManager->lnnAllocTargetLane(INVALID_LANE_REQ_ID, nullptr, &listener);
3108 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
3109 ret = laneManager->lnnAllocTargetLane(INVALID_LANE_REQ_ID, &allocInfo, &listener);
3110 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
3111 allocInfo.type = LANE_TYPE_BUTT;
3112 ret = laneManager->lnnAllocTargetLane(laneHandle, &allocInfo, &listener);
3113 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
3114 allocInfo.type = LANE_TYPE_TRANS;
3115 allocInfo.linkList.linkTypeNum = LANE_LINK_TYPE_BUTT;
3116 ret = laneManager->lnnAllocTargetLane(laneHandle, &allocInfo, &listener);
3117 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
3118 std::this_thread::sleep_for(std::chrono::milliseconds(100));
3119 }
3120
3121 /*
3122 * @tc.name: LNN_LANE_08
3123 * @tc.desc: SelectLaneRule
3124 * @tc.type: FUNC
3125 * @tc.require:
3126 */
3127 HWTEST_F(LNNLaneMockTest, LNN_LANE_08, TestSize.Level1)
3128 {
3129 LaneAllocInfoExt allocInfo;
3130 NiceMock<LaneDepsInterfaceMock> laneDepMock;
3131 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
3132 const LnnLaneManager *laneManager = GetLaneManager();
3133 LaneType laneType = LANE_TYPE_TRANS;
3134 uint32_t laneHandle = laneManager->lnnGetLaneHandle(laneType);
3135 EXPECT_TRUE(laneHandle != INVALID_LANE_REQ_ID);
3136
3137 EXPECT_CALL(laneDepMock, DeleteNetworkResourceByLaneId).WillRepeatedly(Return());
3138 EXPECT_CALL(laneDepMock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
3139 laneDepMock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
3140 laneDepMock.SetDefaultResultForAlloc(1 << BIT_WIFI_P2P, 1 << BIT_WIFI_P2P, 8, 8);
3141 wifiMock.SetDefaultResult();
3142 EXPECT_CALL(wifiMock, LnnConnectP2p(NotNull(), laneHandle, NotNull()))
3143 .WillRepeatedly(LnnWifiAdpterInterfaceMock::ActionOfLnnConnectP2p);
3144 EXPECT_CALL(laneDepMock, LnnGetRemoteStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
3145
3146 allocInfo.linkList.linkTypeNum = LANE_LINK_TYPE_BUTT - 1;
3147 allocInfo.type = LANE_TYPE_TRANS;
3148 int32_t ret = laneManager->lnnAllocTargetLane(laneHandle, &allocInfo, &g_listenerCbForP2p2);
3149 EXPECT_EQ(ret, SOFTBUS_OK);
3150
3151 ret = laneManager->lnnFreeLane(laneHandle);
3152 EXPECT_EQ(ret, SOFTBUS_OK);
3153 std::this_thread::sleep_for(std::chrono::milliseconds(100));
3154 }
3155
3156 /*
3157 * @tc.name: LNN_LANE_09
3158 * @tc.desc: SelectLaneRule
3159 * @tc.type: FUNC
3160 * @tc.require:
3161 */
3162 HWTEST_F(LNNLaneMockTest, LNN_LANE_09, TestSize.Level1)
3163 {
3164 LnnMacInfo macInfo;
3165 LaneLinkInfo linkInfo;
3166 linkInfo.type = LANE_P2P;
3167 NiceMock<LaneDepsInterfaceMock> laneDepMock;
3168
3169 EXPECT_EQ(strncpy_s(linkInfo.linkInfo.p2p.connInfo.localIp, IP_LEN, PEER_IP_HML, strlen(PEER_IP_HML)), EOK);
3170 EXPECT_EQ(strcpy_s(macInfo.localMac, MAX_MAC_LEN, LOCAL_MAC), EOK);
3171 EXPECT_EQ(strcpy_s(macInfo.remoteMac, MAX_MAC_LEN, PEER_MAC), EOK);
3172 int32_t ret = AddLaneResourceToPool(&linkInfo, LANE_ID_BASE, false);
3173 EXPECT_EQ(ret, SOFTBUS_OK);
3174 ret = GetMacInfoByLaneId(LANE_ID_BASE, &macInfo);
3175 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
3176
3177 linkInfo.type = LANE_P2P_REUSE;
3178 ret = AddLaneResourceToPool(&linkInfo, LANE_ID_BASE, false);
3179 EXPECT_EQ(ret, SOFTBUS_OK);
3180 ret = GetMacInfoByLaneId(LANE_ID_BASE, &macInfo);
3181 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
3182
3183 linkInfo.type = LANE_HML;
3184 ret = AddLaneResourceToPool(&linkInfo, LANE_ID_BASE, false);
3185 EXPECT_EQ(ret, SOFTBUS_OK);
3186 ret = GetMacInfoByLaneId(LANE_ID_BASE, &macInfo);
3187 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
3188
3189 linkInfo.type = LANE_ETH;
3190 ret = AddLaneResourceToPool(&linkInfo, LANE_ID_BASE, false);
3191 EXPECT_EQ(ret, SOFTBUS_OK);
3192 EXPECT_CALL(laneDepMock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
3193 ret = GetMacInfoByLaneId(LANE_ID_BASE, &macInfo);
3194 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
3195 }
3196
3197 /*
3198 * @tc.name: LNN_LANE_11
3199 * @tc.desc: SelectLaneRule
3200 * @tc.type: FUNC
3201 * @tc.require:
3202 */
3203 HWTEST_F(LNNLaneMockTest, LNN_LANE_11, TestSize.Level1)
3204 {
3205 LaneLinkInfo linkInfo;
3206 NiceMock<LaneDepsInterfaceMock> laneDepMock;
3207 LnnMacInfo macInfo;
3208 ASSERT_EQ(memset_s(&linkInfo, sizeof(LaneLinkInfo), 0, sizeof(LaneLinkInfo)), EOK);
3209 linkInfo.type = LANE_P2P;
3210 ASSERT_EQ(strncpy_s(linkInfo.linkInfo.p2p.connInfo.peerIp, IP_LEN, PEER_IP_HML, strlen(PEER_IP_HML)), EOK);
3211 ASSERT_EQ(strncpy_s(linkInfo.peerUdid, UDID_BUF_LEN, PEER_UDID, strlen(PEER_UDID)), EOK);
3212 uint64_t laneId = LANE_ID_BASE;
3213 EXPECT_CALL(laneDepMock, LnnGetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
3214 uint32_t ret = AddLaneResourceToPool(&linkInfo, laneId, false);
3215 EXPECT_EQ(ret, SOFTBUS_OK);
3216 EXPECT_CALL(laneDepMock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
3217 ret = GetMacInfoByLaneId(LANE_ID_BASE, &macInfo);
3218 EXPECT_EQ(ret, SOFTBUS_OK);
3219 }
3220
3221 /*
3222 * @tc.name: LNN_LANE_13
3223 * @tc.desc: SelectLaneRule
3224 * @tc.type: FUNC
3225 * @tc.require:
3226 */
3227 HWTEST_F(LNNLaneMockTest, LNN_LANE_13, TestSize.Level1)
3228 {
3229 LaneType laneType = LANE_TYPE_TRANS;
3230 uint32_t laneReqId = ApplyLaneReqId(laneType);
3231 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
3232 NiceMock<LaneDepsInterfaceMock> mock;
3233 EXPECT_CALL(mock, LnnGetLocalNumInfo).WillRepeatedly(DoAll(SetArgPointee<1>(NET_CAP), Return(SOFTBUS_OK)));
3234 EXPECT_CALL(mock, LnnGetRemoteNumInfo).WillRepeatedly(DoAll(SetArgPointee<2>(NET_CAP), Return(SOFTBUS_OK)));
3235 EXPECT_CALL(mock, LnnGetOnlineStateById).WillRepeatedly(Return(true));
3236 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
3237 EXPECT_CALL(wifiMock, SoftBusGetLinkBand).WillRepeatedly(Return(BAND_5G));
3238
3239 LaneRequestOption requestOption = {};
3240 requestOption.type = laneType;
3241 EXPECT_EQ(strncpy_s(requestOption.requestInfo.trans.networkId, NETWORK_ID_BUF_LEN,
3242 NODE_NETWORK_ID, strlen(NODE_NETWORK_ID)), EOK);
3243 requestOption.requestInfo.trans.transType = LANE_T_COMMON_VIDEO;
3244 requestOption.requestInfo.trans.expectedBw = 0;
3245 requestOption.requestInfo.trans.pid = 0;
3246 requestOption.requestInfo.trans.expectedLink.linkTypeNum = 1;
3247 requestOption.requestInfo.trans.expectedLink.linkType[0] = LANE_WLAN_5G;
3248
3249 int32_t ret = LnnRequestLane(laneReqId, &requestOption, &g_listener2);
3250 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_OFF);
3251 }
3252
3253 /*
3254 * @tc.name: LNN_LANE_14
3255 * @tc.desc: SelectLaneRule
3256 * @tc.type: FUNC
3257 * @tc.require:
3258 */
3259 HWTEST_F(LNNLaneMockTest, LNN_LANE_14, TestSize.Level1)
3260 {
3261 NiceMock<LaneDepsInterfaceMock> mock;
3262 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
3263 LaneSelectParam selectParam = {};
3264 LanePreferredLinkList linkList = {};
3265 selectParam.transType = LANE_T_RAW_STREAM;
3266 selectParam.qosRequire.minBW = DEFAULT_QOSINFO_MIN_BW;
3267 selectParam.qosRequire.maxLaneLatency = DEFAULT_QOSINFO_MAX_LATENCY;
3268 selectParam.qosRequire.minLaneLatency = DEFAULT_QOSINFO_MIN_LATENCY;
3269
3270 wifiMock.SetDefaultResult();
3271 EXPECT_CALL(wifiMock, SoftBusGetLinkBand).WillRepeatedly(Return(BAND_24G));
3272 EXPECT_CALL(wifiMock, SoftBusGetWifiState).WillRepeatedly(Return(SOFTBUS_WIFI_STATE_SEMIACTIVATING));
3273 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
3274 EXPECT_CALL(mock, LnnGetLocalNumInfo)
3275 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(1), Return(SOFTBUS_OK)));
3276 EXPECT_CALL(mock, LnnGetRemoteNumInfo)
3277 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(1), Return(SOFTBUS_OK)));
3278 EXPECT_CALL(mock, LnnGetOnlineStateById).WillRepeatedly(Return(true));
3279
3280 int32_t ret = DecideAvailableLane(NODE_NETWORK_ID, &selectParam, &linkList);
3281 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_BAND_ERR);
3282 }
3283
3284 /*
3285 * @tc.name: LNN_LANE_15
3286 * @tc.desc: SelectLaneRule
3287 * @tc.type: FUNC
3288 * @tc.require:
3289 */
3290 HWTEST_F(LNNLaneMockTest, LNN_LANE_15, TestSize.Level1)
3291 {
3292 NiceMock<LaneDepsInterfaceMock> mock;
3293 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
3294 LaneSelectParam selectParam = {};
3295 LanePreferredLinkList linkList = {};
3296 selectParam.transType = LANE_T_RAW_STREAM;
3297 selectParam.qosRequire.minBW = DEFAULT_QOSINFO_MIN_BW;
3298 selectParam.qosRequire.maxLaneLatency = DEFAULT_QOSINFO_MAX_LATENCY;
3299 selectParam.qosRequire.minLaneLatency = DEFAULT_QOSINFO_MIN_LATENCY;
3300
3301 wifiMock.SetDefaultResult();
3302 EXPECT_CALL(wifiMock, SoftBusGetLinkBand).WillRepeatedly(Return(BAND_5G));
3303 EXPECT_CALL(wifiMock, SoftBusGetWifiState).WillRepeatedly(Return(SOFTBUS_WIFI_STATE_SEMIACTIVATING));
3304 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
3305 EXPECT_CALL(mock, LnnGetLocalNumInfo)
3306 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(1), Return(SOFTBUS_OK)));
3307 EXPECT_CALL(mock, LnnGetRemoteNumInfo)
3308 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(1), Return(SOFTBUS_OK)));
3309 EXPECT_CALL(mock, LnnGetOnlineStateById).WillRepeatedly(Return(true));
3310 EXPECT_CALL(mock, LnnGetLocalNumU32Info).WillRepeatedly(Return(SOFTBUS_ERR));
3311 int32_t ret = DecideAvailableLane(NODE_NETWORK_ID, &selectParam, &linkList);
3312 EXPECT_EQ(ret, SOFTBUS_LANE_GET_LEDGER_INFO_ERR);
3313 }
3314
3315 /*
3316 * @tc.name: LNN_LANE_16
3317 * @tc.desc: SelectLaneRule
3318 * @tc.type: FUNC
3319 * @tc.require:
3320 */
3321 HWTEST_F(LNNLaneMockTest, LNN_LANE_16, TestSize.Level1)
3322 {
3323 NiceMock<LaneDepsInterfaceMock> mock;
3324 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
3325 LaneSelectParam selectParam = {};
3326 LanePreferredLinkList linkList = {};
3327 selectParam.transType = LANE_T_RAW_STREAM;
3328 selectParam.qosRequire.minBW = HIGH_BW;
3329 selectParam.qosRequire.maxLaneLatency = DEFAULT_QOSINFO_MAX_LATENCY;
3330 selectParam.qosRequire.minLaneLatency = DEFAULT_QOSINFO_MIN_LATENCY;
3331
3332 wifiMock.SetDefaultResult();
3333 EXPECT_CALL(wifiMock, SoftBusGetLinkBand).WillRepeatedly(Return(BAND_5G));
3334 EXPECT_CALL(wifiMock, SoftBusGetWifiState).WillRepeatedly(Return(SOFTBUS_WIFI_STATE_SEMIACTIVATING));
3335 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
3336 EXPECT_CALL(mock, LnnGetLocalNumInfo)
3337 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(1), Return(SOFTBUS_OK)));
3338 EXPECT_CALL(mock, LnnGetRemoteNumInfo)
3339 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(1), Return(SOFTBUS_OK)));
3340 EXPECT_CALL(mock, LnnGetOnlineStateById).WillRepeatedly(Return(true));
3341 EXPECT_CALL(mock, LnnGetLocalNumU32Info).WillRepeatedly(Return(SOFTBUS_ERR));
3342 int32_t ret = DecideAvailableLane(NODE_NETWORK_ID, &selectParam, &linkList);
3343 EXPECT_EQ(ret, SOFTBUS_LANE_GET_LEDGER_INFO_ERR);
3344 }
3345
3346 /*
3347 * @tc.name: LNN_LANE_17
3348 * @tc.desc: SelectLaneRule
3349 * @tc.type: FUNC
3350 * @tc.require:
3351 */
3352 HWTEST_F(LNNLaneMockTest, LNN_LANE_17, TestSize.Level1)
3353 {
3354 NiceMock<LaneDepsInterfaceMock> mock;
3355 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
3356 uint32_t listNum = 0;
3357 LanePreferredLinkList linkList = {};
3358 LaneSelectParam selectParam = {};
3359 selectParam.transType = LANE_T_FILE;
3360 selectParam.expectedBw = 0;
3361 selectParam.list.linkTypeNum = 2;
3362 selectParam.list.linkType[0] = LANE_WLAN_2P4G;
3363 selectParam.list.linkType[1] = LANE_COC_DIRECT;
3364 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
3365 EXPECT_CALL(mock, LnnGetLocalNumU32Info)
3366 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(16), Return(SOFTBUS_OK)));
3367 EXPECT_CALL(mock, LnnGetRemoteNumU32Info)
3368 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(16), Return(SOFTBUS_OK)));
3369 EXPECT_CALL(mock, LnnGetLocalNumInfo).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
3370 EXPECT_CALL(mock, LnnGetRemoteNumInfo).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
3371 EXPECT_CALL(mock, LnnGetLocalNumU64Info).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
3372 EXPECT_CALL(mock, LnnGetRemoteNumU64Info).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
3373 EXPECT_CALL(mock, LnnHasDiscoveryType).WillRepeatedly(Return(true));
3374 EXPECT_CALL(mock, LnnGetRemoteNodeInfoById).WillRepeatedly(Return(SOFTBUS_OK));
3375 wifiMock.SetDefaultResult();
3376 SoftBusWifiLinkedInfo wlanInfo;
3377 wlanInfo.frequency = 1;
3378 EXPECT_CALL(wifiMock, SoftBusGetWifiState).WillRepeatedly(Return(SOFTBUS_WIFI_STATE_SEMIACTIVATING));
3379 EXPECT_CALL(wifiMock, SoftBusGetLinkedInfo)
3380 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM1>(wlanInfo), Return(SOFTBUS_OK)));
3381 int32_t ret = SelectLane(NODE_NETWORK_ID, &selectParam, &linkList, &listNum);
3382 EXPECT_EQ(ret, SOFTBUS_OK);
3383 }
3384
3385 /*
3386 * @tc.name: LNN_LANE_18
3387 * @tc.desc: SelectLaneRule
3388 * @tc.type: FUNC
3389 * @tc.require:
3390 */
3391 HWTEST_F(LNNLaneMockTest, LNN_LANE_18, TestSize.Level1)
3392 {
3393 NiceMock<LaneDepsInterfaceMock> mock;
3394 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
3395 uint32_t listNum = 0;
3396 LanePreferredLinkList linkList = {};
3397 LaneSelectParam selectParam = {};
3398 selectParam.transType = LANE_T_FILE;
3399 selectParam.expectedBw = 0;
3400 selectParam.list.linkTypeNum = 2;
3401 selectParam.list.linkType[0] = LANE_WLAN_2P4G;
3402 selectParam.list.linkType[1] = LANE_COC_DIRECT;
3403 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
3404 EXPECT_CALL(mock, LnnGetLocalNumU32Info)
3405 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(16), Return(SOFTBUS_OK)));
3406 EXPECT_CALL(mock, LnnGetRemoteNumU32Info)
3407 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(16), Return(SOFTBUS_OK)));
3408 EXPECT_CALL(mock, LnnGetLocalNumInfo).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
3409 EXPECT_CALL(mock, LnnGetRemoteNumInfo).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
3410 EXPECT_CALL(mock, LnnGetLocalNumU64Info).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
3411 EXPECT_CALL(mock, LnnGetRemoteNumU64Info).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
3412 EXPECT_CALL(mock, LnnHasDiscoveryType).WillRepeatedly(Return(true));
3413 EXPECT_CALL(mock, LnnGetRemoteNodeInfoById).WillRepeatedly(Return(SOFTBUS_OK));
3414 wifiMock.SetDefaultResult();
3415 SoftBusWifiLinkedInfo wlanInfo;
3416 wlanInfo.frequency = FREQUENCY_2G_FIRST + 1;
3417 EXPECT_CALL(wifiMock, SoftBusGetLinkedInfo)
3418 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM1>(wlanInfo), Return(SOFTBUS_OK)));
3419 EXPECT_CALL(wifiMock, SoftBusGetWifiState).WillRepeatedly(Return(SOFTBUS_WIFI_STATE_SEMIACTIVATING));
3420 int32_t ret = SelectLane(NODE_NETWORK_ID, &selectParam, &linkList, &listNum);
3421 EXPECT_EQ(ret, SOFTBUS_OK);
3422 }
3423
3424 /*
3425 * @tc.name: LNN_LANE_19
3426 * @tc.desc: SelectLaneRule
3427 * @tc.type: FUNC
3428 * @tc.require:
3429 */
3430 HWTEST_F(LNNLaneMockTest, LNN_LANE_19, TestSize.Level1)
3431 {
3432 LaneLinkType linkType = LANE_COC_DIRECT;
3433 NiceMock<LaneDepsInterfaceMock> linkMock;
3434 EXPECT_CALL(linkMock, LnnGetLocalNumU32Info)
3435 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(1), Return(SOFTBUS_OK)));
3436 EXPECT_CALL(linkMock, LnnGetRemoteNumU32Info)
3437 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(1), Return(SOFTBUS_OK)));
3438 EXPECT_CALL(linkMock, LnnGetLocalNumU64Info)
3439 .WillOnce(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(ROM_NUM), Return(SOFTBUS_OK)))
3440 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(LOCAL_NUM), Return(SOFTBUS_OK)));
3441 EXPECT_CALL(linkMock, LnnGetRemoteNumU64Info)
3442 .WillOnce(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(ROM_NUM), Return(SOFTBUS_OK)))
3443 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(LOCAL_NUM), Return(SOFTBUS_OK)));
3444 int32_t ret = LaneCapCheck(NODE_NETWORK_ID, linkType);
3445 EXPECT_EQ(ret, SOFTBUS_LANE_LOCAL_NO_COC_CAP);
3446 }
3447
3448 /*
3449 * @tc.name: LNN_LANE_20
3450 * @tc.desc: SelectLaneRule
3451 * @tc.type: FUNC
3452 * @tc.require:
3453 */
3454 HWTEST_F(LNNLaneMockTest, LNN_LANE_20, TestSize.Level1)
3455 {
3456 LaneLinkType linkType = LANE_P2P_REUSE;
3457 NiceMock<LaneDepsInterfaceMock> linkMock;
3458 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
3459 EXPECT_CALL(linkMock, LnnGetLocalNumU32Info)
3460 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(0), Return(SOFTBUS_OK)));
3461 EXPECT_CALL(linkMock, LnnGetRemoteNumU32Info)
3462 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(0), Return(SOFTBUS_OK)));
3463 EXPECT_CALL(wifiMock, SoftBusGetWifiState).WillRepeatedly(Return(SOFTBUS_WIFI_STATE_DEACTIVATING));
3464 int32_t ret = LaneCapCheck(NODE_NETWORK_ID, linkType);
3465 EXPECT_EQ(ret, SOFTBUS_LANE_LOCAL_NO_WIFI_DIRECT_CAP);
3466 }
3467
3468 /*
3469 * @tc.name: LNN_LANE_21
3470 * @tc.desc: SelectLaneRule
3471 * @tc.type: FUNC
3472 * @tc.require:
3473 */
3474 HWTEST_F(LNNLaneMockTest, LNN_LANE_21, TestSize.Level1)
3475 {
3476 LaneLinkType linkType = LANE_P2P_REUSE;
3477 NiceMock<LaneDepsInterfaceMock> linkMock;
3478 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
3479 EXPECT_CALL(linkMock, LnnGetLocalNumU32Info)
3480 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(0), Return(SOFTBUS_OK)));
3481 EXPECT_CALL(linkMock, LnnGetRemoteNumU32Info)
3482 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(0), Return(SOFTBUS_OK)));
3483 EXPECT_CALL(wifiMock, SoftBusGetWifiState).WillRepeatedly(Return(SOFTBUS_WIFI_STATE_SEMIACTIVATING));
3484 int32_t ret = LaneCapCheck(NODE_NETWORK_ID, linkType);
3485 EXPECT_EQ(ret, SOFTBUS_LANE_REMOTE_NO_WIFI_DIRECT_CAP);
3486 }
3487
3488 /*
3489 * @tc.name: LNN_LANE_22
3490 * @tc.desc: SelectLaneRule
3491 * @tc.type: FUNC
3492 * @tc.require:
3493 */
3494 HWTEST_F(LNNLaneMockTest, LNN_LANE_22, TestSize.Level1)
3495 {
3496 LaneLinkType linkType = LANE_P2P_REUSE;
3497 NiceMock<LaneDepsInterfaceMock> linkMock;
3498 EXPECT_CALL(linkMock, LnnGetLocalNumU32Info)
3499 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(ROM_NUM), Return(SOFTBUS_OK)));
3500 EXPECT_CALL(linkMock, LnnGetRemoteNumU32Info)
3501 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(ROM_NUM), Return(SOFTBUS_OK)));
3502 EXPECT_CALL(linkMock, LnnGetLocalNumU64Info)
3503 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(0), Return(SOFTBUS_OK)));
3504 EXPECT_CALL(linkMock, LnnGetRemoteNumU64Info)
3505 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(0), Return(SOFTBUS_OK)));
3506 int32_t ret = LaneCapCheck(NODE_NETWORK_ID, linkType);
3507 EXPECT_EQ(ret, SOFTBUS_LANE_LOCAL_NO_WIFI_DIRECT_CAP);
3508
3509 EXPECT_CALL(linkMock, LnnGetLocalNumU64Info)
3510 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(ROM_NUM2), Return(SOFTBUS_OK)));
3511 EXPECT_CALL(linkMock, LnnGetRemoteNumU64Info)
3512 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(ROM_NUM2), Return(SOFTBUS_OK)));
3513 ret = LaneCapCheck(NODE_NETWORK_ID, linkType);
3514 EXPECT_EQ(ret, SOFTBUS_OK);
3515 }
3516
3517 /*
3518 * @tc.name: LNN_LANE_23
3519 * @tc.desc: SelectLaneRule
3520 * @tc.type: FUNC
3521 * @tc.require:
3522 */
3523 HWTEST_F(LNNLaneMockTest, LNN_LANE_23, TestSize.Level1)
3524 {
3525 NiceMock<LaneDepsInterfaceMock> mock;
3526 LanePreferredLinkList linkList = {};
3527 uint32_t listNum = 0;
3528 LaneSelectParam selectParam = {};
3529 EXPECT_CALL(mock, LnnGetOnlineStateById).WillRepeatedly(Return(false));
3530 int32_t ret = SelectLane(NODE_NETWORK_ID, &selectParam, &linkList, &listNum);
3531 EXPECT_EQ(ret, SOFTBUS_NETWORK_NODE_OFFLINE);
3532
3533 ret = SelectLane(nullptr, &selectParam, &linkList, &listNum);
3534 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
3535 ret = SelectLane(NODE_NETWORK_ID, &selectParam, &linkList, nullptr);
3536 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
3537 }
3538
3539 /*
3540 * @tc.name: LNN_LANE_24
3541 * @tc.desc: SelectLaneRule
3542 * @tc.type: FUNC
3543 * @tc.require:
3544 */
3545 HWTEST_F(LNNLaneMockTest, LNN_LANE_24, TestSize.Level1)
3546 {
3547 LanePreferredLinkList recommendList = {};
3548 LaneSelectParam selectParam = {};
3549 int32_t ret = SelectExpectLanesByQos(nullptr, &selectParam, &recommendList);
3550 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
3551 ret = SelectExpectLanesByQos(NODE_NETWORK_ID, &selectParam, nullptr);
3552 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
3553 }
3554
3555 /*
3556 * @tc.name: LNN_LANE_25
3557 * @tc.desc: SelectLaneRule
3558 * @tc.type: FUNC
3559 * @tc.require:
3560 */
3561 HWTEST_F(LNNLaneMockTest, LNN_LANE_25, TestSize.Level1)
3562 {
3563 LaneLinkType linkType = LANE_ETH;
3564 int32_t ret = LaneCapCheck(NODE_NETWORK_ID, linkType);
3565 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
3566 }
3567 } // namespace OHOS
3568