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 PEER_UDID[] = "111122223333abcdef";
51 constexpr uint64_t LANE_ID_BASE = 1122334455667788;
52 constexpr uint32_t DEFAULT_QOSINFO_MIN_BW = 10;
53 constexpr uint32_t DEFAULT_QOSINFO_MAX_LATENCY = 10000;
54 constexpr uint32_t DEFAULT_QOSINFO_MIN_LATENCY = 2500;
55 constexpr uint32_t DEFAULT_LANE_RESOURCE_LANE_REF = 0;
56 constexpr uint32_t LOW_BW = 384 * 1024;
57 constexpr uint32_t MID_BW = 30 * 1024 * 1024;
58 constexpr uint32_t HIGH_BW = 160 * 1024 * 1024;
59 constexpr uint32_t PORT_A = 22;
60 constexpr uint32_t PORT_B = 25;
61 constexpr uint32_t FD = 888;
62 constexpr uint32_t SLEEP_FOR_LOOP_COMPLETION_MS = 50;
63 constexpr uint32_t NET_CAP = 63;
64
65 static SoftBusCond g_cond = {0};
66 static SoftBusMutex g_lock = {0};
67 static int32_t g_errCode = 0;
68 static bool g_isNeedCondWait = true;
69
70 static void OnLaneAllocSuccess(uint32_t laneHandle, const LaneConnInfo *info);
71 static void OnLaneAllocFail(uint32_t laneHandle, int32_t errCode);
72 static void OnLaneFreeSuccess(uint32_t laneHandle);
73 static void OnLaneFreeFail(uint32_t laneHandle, int32_t errCode);
74
75 static LaneAllocListener g_listener = {
76 .onLaneAllocSuccess = OnLaneAllocSuccess,
77 .onLaneAllocFail = OnLaneAllocFail,
78 .onLaneFreeSuccess = OnLaneFreeSuccess,
79 .onLaneFreeFail = OnLaneFreeFail,
80 };
81
OnLaneRequestSuccess(uint32_t laneId,const LaneConnInfo * info)82 static void OnLaneRequestSuccess(uint32_t laneId, const LaneConnInfo *info)
83 {
84 GTEST_LOG_(INFO) << "OnLaneRequestSuccess";
85 }
86
OnLaneRequestFail(uint32_t laneId,int32_t reason)87 static void OnLaneRequestFail(uint32_t laneId, int32_t reason)
88 {
89 GTEST_LOG_(INFO) << "OnLaneRequestFail";
90 }
91
92 static ILaneListener g_listener2 = {
93 .onLaneRequestSuccess = OnLaneRequestSuccess,
94 .onLaneRequestFail = OnLaneRequestFail,
95 };
96
97 static NodeInfo g_NodeInfo = {
98 .p2pInfo.p2pRole = 1,
99 .p2pInfo.p2pMac = "abc",
100 .p2pInfo.goMac = "abc",
101 };
102
103 class LNNLaneMockTest : public testing::Test {
104 public:
105 static void SetUpTestCase();
106 static void TearDownTestCase();
107 void SetUp();
108 void TearDown();
109 };
110
SetUpTestCase()111 void LNNLaneMockTest::SetUpTestCase()
112 {
113 (void)SoftBusMutexInit(&g_lock, nullptr);
114 (void)SoftBusCondInit(&g_cond);
115 int32_t ret = LnnInitLnnLooper();
116 EXPECT_TRUE(ret == SOFTBUS_OK);
117 ret = LooperInit();
118 NiceMock<LaneDepsInterfaceMock> mock;
119 EXPECT_CALL(mock, StartBaseClient).WillRepeatedly(LaneDepsInterfaceMock::ActionOfStartBaseClient);
120 ret = InitLane();
121 EXPECT_TRUE(ret == SOFTBUS_OK);
122 GTEST_LOG_(INFO) << "LNNLaneMockTest start";
123 }
124
TearDownTestCase()125 void LNNLaneMockTest::TearDownTestCase()
126 {
127 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
128 EXPECT_CALL(wifiMock, LnnDestroyP2p).WillRepeatedly(Return());
129 DeinitLane();
130 LooperDeinit();
131 LnnDeinitLnnLooper();
132 (void)SoftBusCondDestroy(&g_cond);
133 (void)SoftBusMutexDestroy(&g_lock);
134 GTEST_LOG_(INFO) << "LNNLaneMockTest end";
135 }
136
SetUp()137 void LNNLaneMockTest::SetUp()
138 {
139 }
140
TearDown()141 void LNNLaneMockTest::TearDown()
142 {
143 }
144
CondSignal(void)145 static void CondSignal(void)
146 {
147 if (SoftBusMutexLock(&g_lock) != SOFTBUS_OK) {
148 GTEST_LOG_(INFO) << "CondSignal SoftBusMutexLock failed";
149 return;
150 }
151 if (SoftBusCondSignal(&g_cond) != SOFTBUS_OK) {
152 GTEST_LOG_(INFO) << "CondSignal SoftBusCondSignal failed";
153 (void)SoftBusMutexUnlock(&g_lock);
154 return;
155 }
156 g_isNeedCondWait = false;
157 (void)SoftBusMutexUnlock(&g_lock);
158 }
159
ComputeWaitForceDownTime(uint32_t waitMillis,SoftBusSysTime * outtime)160 static void ComputeWaitForceDownTime(uint32_t waitMillis, SoftBusSysTime *outtime)
161 {
162 #define USECTONSEC 1000
163 SoftBusSysTime now;
164 (void)SoftBusGetTime(&now);
165 int64_t time = now.sec * USECTONSEC * USECTONSEC + now.usec + (int64_t)waitMillis * USECTONSEC;
166 outtime->sec = time / USECTONSEC / USECTONSEC;
167 outtime->usec = time % (USECTONSEC * USECTONSEC);
168 }
169
CondWait(void)170 static void CondWait(void)
171 {
172 if (SoftBusMutexLock(&g_lock) != SOFTBUS_OK) {
173 GTEST_LOG_(INFO) << "CondWait SoftBusMutexLock failed";
174 return;
175 }
176 if (!g_isNeedCondWait) {
177 GTEST_LOG_(INFO) << "Doesn't need CondWait, g_isNeedCondWait = " << g_isNeedCondWait;
178 (void)SoftBusMutexUnlock(&g_lock);
179 return;
180 }
181 SoftBusSysTime waitTime = {0};
182 uint32_t condWaitTimeout = 3000;
183 ComputeWaitForceDownTime(condWaitTimeout, &waitTime);
184 if (SoftBusCondWait(&g_cond, &g_lock, &waitTime) != SOFTBUS_OK) {
185 GTEST_LOG_(INFO) << "CondWait Timeout end";
186 (void)SoftBusMutexUnlock(&g_lock);
187 return;
188 }
189 (void)SoftBusMutexUnlock(&g_lock);
190 }
191
SetIsNeedCondWait(void)192 static void SetIsNeedCondWait(void)
193 {
194 if (SoftBusMutexLock(&g_lock) != SOFTBUS_OK) {
195 GTEST_LOG_(INFO) << "SetIsNeedCondWait SoftBusMutexLock failed";
196 return;
197 }
198 g_isNeedCondWait = true;
199 (void)SoftBusMutexUnlock(&g_lock);
200 }
201
OnLaneAllocSuccess(uint32_t laneHandle,const LaneConnInfo * info)202 static void OnLaneAllocSuccess(uint32_t laneHandle, const LaneConnInfo *info)
203 {
204 ASSERT_NE(info, nullptr) << "invalid info";
205 GTEST_LOG_(INFO) << "alloc lane successful, laneReqId=" << laneHandle << ", linkType=" << info->type;
206 const LnnLaneManager *laneManager = GetLaneManager();
207 int32_t ret = laneManager->lnnFreeLane(laneHandle);
208 EXPECT_TRUE(ret == SOFTBUS_OK);
209 CondSignal();
210 }
211
OnLaneAllocFail(uint32_t laneHandle,int32_t errCode)212 static void OnLaneAllocFail(uint32_t laneHandle, int32_t errCode)
213 {
214 GTEST_LOG_(INFO) << "alloc lane failed, laneReqId=" << laneHandle << ", errCode=" << errCode;
215 EXPECT_NE(errCode, SOFTBUS_OK);
216 g_errCode = errCode;
217 const LnnLaneManager *laneManager = GetLaneManager();
218 int32_t ret = laneManager->lnnFreeLane(laneHandle);
219 EXPECT_TRUE(ret == SOFTBUS_OK);
220 CondSignal();
221 }
222
OnLaneFreeSuccess(uint32_t laneHandle)223 static void OnLaneFreeSuccess(uint32_t laneHandle)
224 {
225 GTEST_LOG_(INFO) << "free lane success, laneReqId=" << laneHandle;
226 CondSignal();
227 }
228
OnLaneFreeFail(uint32_t laneHandle,int32_t errCode)229 static void OnLaneFreeFail(uint32_t laneHandle, int32_t errCode)
230 {
231 GTEST_LOG_(INFO) << "free lane failed, laneReqId=" << laneHandle << ", errCode=" << errCode;
232 CondSignal();
233 }
234
OnLaneLinkFail(uint32_t reqId,int32_t reason,LaneLinkType linkType)235 static void OnLaneLinkFail(uint32_t reqId, int32_t reason, LaneLinkType linkType)
236 {
237 (void)reqId;
238 (void)reason;
239 (void)linkType;
240 return;
241 }
242
OnLaneLinkSuccess(uint32_t reqId,LaneLinkType linkType,const LaneLinkInfo * linkInfo)243 static void OnLaneLinkSuccess(uint32_t reqId, LaneLinkType linkType, const LaneLinkInfo *linkInfo)
244 {
245 (void)reqId;
246 (void)linkType;
247 (void)linkInfo;
248 return;
249 }
250
OnLaneLinkSuccessForDetect(uint32_t reqId,LaneLinkType linkType,const LaneLinkInfo * linkInfo)251 static void OnLaneLinkSuccessForDetect(uint32_t reqId, LaneLinkType linkType, const LaneLinkInfo *linkInfo)
252 {
253 (void)reqId;
254 (void)linkInfo;
255 GTEST_LOG_(INFO) << "on laneLink success for detect";
256 EXPECT_EQ(linkType, LANE_WLAN_5G);
257 }
258
OnLaneLinkFailForDetect(uint32_t reqId,int32_t reason,LaneLinkType linkType)259 static void OnLaneLinkFailForDetect(uint32_t reqId, int32_t reason, LaneLinkType linkType)
260 {
261 (void)reqId;
262 (void)linkType;
263 GTEST_LOG_(INFO) << "on laneLink fail for detect";
264 EXPECT_EQ(reason, SOFTBUS_LANE_DETECT_TIMEOUT);
265 CondSignal();
266 }
267
OnLaneAllocSuccessForHml(uint32_t laneHandle,const LaneConnInfo * info)268 static void OnLaneAllocSuccessForHml(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_HML);
274 CondSignal();
275 }
276
OnLaneAllocSuccessForP2p(uint32_t laneHandle,const LaneConnInfo * info)277 static void OnLaneAllocSuccessForP2p(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_P2P);
283 CondSignal();
284 }
285
OnLaneAllocSuccessForBr(uint32_t laneHandle,const LaneConnInfo * info)286 static void OnLaneAllocSuccessForBr(uint32_t laneHandle, const LaneConnInfo *info)
287 {
288 (void)laneHandle;
289 ASSERT_NE(info, nullptr) << "invalid connInfo";
290 GTEST_LOG_(INFO) << "alloc lane successful, linkType=" << info->type;
291 EXPECT_EQ(info->type, LANE_BR);
292 CondSignal();
293 }
294
OnLaneAllocSuccessForWlan5g(uint32_t laneHandle,const LaneConnInfo * info)295 static void OnLaneAllocSuccessForWlan5g(uint32_t laneHandle, const LaneConnInfo *info)
296 {
297 (void)laneHandle;
298 ASSERT_NE(info, nullptr) << "invalid connInfo";
299 GTEST_LOG_(INFO) << "alloc lane successful, linkType=" << info->type;
300 EXPECT_EQ(info->type, LANE_WLAN_5G);
301 CondSignal();
302 }
303
OnLaneAllocSuccessForBle(uint32_t laneHandle,const LaneConnInfo * info)304 static void OnLaneAllocSuccessForBle(uint32_t laneHandle, const LaneConnInfo *info)
305 {
306 (void)laneHandle;
307 ASSERT_NE(info, nullptr) << "invalid connInfo";
308 GTEST_LOG_(INFO) << "alloc lane successful, linkType=" << info->type;
309 EXPECT_EQ(info->type, LANE_BLE);
310 CondSignal();
311 }
312
OnLaneAllocFailNoExcept(uint32_t laneHandle,int32_t errCode)313 static void OnLaneAllocFailNoExcept(uint32_t laneHandle, int32_t errCode)
314 {
315 GTEST_LOG_(INFO) << "alloc lane failed, laneReqId=" << laneHandle;
316 EXPECT_EQ(errCode, SOFTBUS_LANE_SUCC_AFTER_CANCELED);
317 CondSignal();
318 }
319
OnLaneAllocFailNoExcept2(uint32_t laneHandle,int32_t errCode)320 static void OnLaneAllocFailNoExcept2(uint32_t laneHandle, int32_t errCode)
321 {
322 GTEST_LOG_(INFO) << "alloc lane failed, laneReqId=" << laneHandle;
323 EXPECT_EQ(errCode, SOFTBUS_LANE_GET_LEDGER_INFO_ERR);
324 CondSignal();
325 }
326
327 static LaneAllocListener g_listenerCbForHml = {
328 .onLaneAllocSuccess = OnLaneAllocSuccessForHml,
329 .onLaneAllocFail = OnLaneAllocFailNoExcept2,
330 .onLaneFreeSuccess = OnLaneFreeSuccess,
331 .onLaneFreeFail = OnLaneFreeFail,
332 };
333
334 static LaneAllocListener g_listenerCbForP2p = {
335 .onLaneAllocSuccess = OnLaneAllocSuccessForP2p,
336 .onLaneAllocFail = OnLaneAllocFailNoExcept,
337 .onLaneFreeSuccess = OnLaneFreeSuccess,
338 .onLaneFreeFail = OnLaneFreeFail,
339 };
340
341 static LaneAllocListener g_listenerCbForBr2 = {
342 .onLaneAllocSuccess = OnLaneAllocSuccessForBr,
343 .onLaneAllocFail = OnLaneAllocFailNoExcept2,
344 .onLaneFreeSuccess = OnLaneFreeSuccess,
345 .onLaneFreeFail = OnLaneFreeFail,
346 };
347
348 static LaneAllocListener g_listenerCbForBr = {
349 .onLaneAllocSuccess = OnLaneAllocSuccessForBr,
350 .onLaneAllocFail = OnLaneAllocFailNoExcept2,
351 .onLaneFreeSuccess = OnLaneFreeSuccess,
352 .onLaneFreeFail = OnLaneFreeFail,
353 };
354
355 static LaneAllocListener g_listenerCbForWlan5g = {
356 .onLaneAllocSuccess = OnLaneAllocSuccessForWlan5g,
357 .onLaneAllocFail = OnLaneAllocFailNoExcept2,
358 .onLaneFreeSuccess = OnLaneFreeSuccess,
359 .onLaneFreeFail = OnLaneFreeFail,
360 };
361
362 static LaneAllocListener g_listenerCbForBle = {
363 .onLaneAllocSuccess = OnLaneAllocSuccessForBle,
364 .onLaneAllocFail = OnLaneAllocFailNoExcept2,
365 .onLaneFreeSuccess = OnLaneFreeSuccess,
366 .onLaneFreeFail = OnLaneFreeFail,
367 };
368
AddLaneResourceForAllocTest(LaneLinkType linkType)369 static int32_t AddLaneResourceForAllocTest(LaneLinkType linkType)
370 {
371 LaneLinkInfo linkInfo = {};
372 linkInfo.type = linkType;
373 if (strncpy_s(linkInfo.linkInfo.p2p.connInfo.peerIp, IP_LEN, PEER_IP_HML, strlen(PEER_IP_HML)) != EOK) {
374 return SOFTBUS_STRCPY_ERR;
375 }
376 if (strncpy_s(linkInfo.peerUdid, UDID_BUF_LEN, PEER_UDID, strlen(PEER_UDID)) != EOK) {
377 return SOFTBUS_STRCPY_ERR;
378 }
379 return AddLaneResourceToPool(&linkInfo, LANE_ID_BASE, false);
380 }
381
CreateAllocInfoForAllocTest(LaneTransType transType,uint32_t minBW,uint32_t maxLaneLatency,uint32_t minLaneLatency,LaneAllocInfo * allocInfo)382 static void CreateAllocInfoForAllocTest(LaneTransType transType, uint32_t minBW, uint32_t maxLaneLatency,
383 uint32_t minLaneLatency, LaneAllocInfo *allocInfo)
384 {
385 ASSERT_NE(allocInfo, nullptr) << "invalid allocInfo";
386 allocInfo->type = LANE_TYPE_TRANS;
387 ASSERT_EQ(strncpy_s(allocInfo->networkId, NETWORK_ID_BUF_LEN,
388 NODE_NETWORK_ID, strlen(NODE_NETWORK_ID)), EOK);
389 allocInfo->transType = transType;
390 allocInfo->qosRequire.minBW = minBW;
391 allocInfo->qosRequire.maxLaneLatency = maxLaneLatency;
392 allocInfo->qosRequire.minLaneLatency = minLaneLatency;
393 }
394
PrejudgeAvailability(const char * remoteNetworkId,enum WifiDirectLinkType connectType)395 static int32_t PrejudgeAvailability(const char *remoteNetworkId, enum WifiDirectLinkType connectType)
396 {
397 (void)remoteNetworkId;
398 (void)connectType;
399 GTEST_LOG_(INFO) << "PrejudgeAvailability Enter";
400 return SOFTBUS_OK;
401 }
402
GetLocalAndRemoteMacByLocalIp(const char * localIp,char * localMac,size_t localMacSize,char * remoteMac,size_t remoteMacSize)403 static int32_t GetLocalAndRemoteMacByLocalIp(const char *localIp, char *localMac, size_t localMacSize,
404 char *remoteMac, size_t remoteMacSize)
405 {
406 (void)localIp;
407 (void)localMac;
408 (void)localMacSize;
409 (void)remoteMac;
410 (void)remoteMacSize;
411 return SOFTBUS_OK;
412 }
413
414 static struct WifiDirectManager g_manager = {
415 .prejudgeAvailability = PrejudgeAvailability,
416 .getLocalAndRemoteMacByLocalIp = GetLocalAndRemoteMacByLocalIp,
417 };
418 /*
419 * @tc.name: LANE_ALLOC_ErrTest_001
420 * @tc.desc: lane errcode test
421 * @tc.type: FUNC
422 * @tc.require:
423 */
424 HWTEST_F(LNNLaneMockTest, LANE_ALLOC_ERRTEST_001, TestSize.Level1)
425 {
426 const LnnLaneManager *laneManager = GetLaneManager();
427 LaneType laneType = LANE_TYPE_TRANS;
428 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
429 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
430
431 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
432 wifiMock.SetDefaultResult();
433 EXPECT_CALL(wifiMock, LnnConnectP2p(NotNull(), laneReqId, NotNull()))
434 .WillRepeatedly(LnnWifiAdpterInterfaceMock::ActionOfOnConnectP2pFail);
435 NiceMock<LaneDepsInterfaceMock> mock;
436 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
437 mock.SetDefaultResultForAlloc(63, 63, 0, 0);
438 EXPECT_CALL(mock, ConnOpenClientSocket).WillRepeatedly(Return(SOFTBUS_CONN_FAIL));
439 EXPECT_CALL(mock, DeleteNetworkResourceByLaneId).WillRepeatedly(Return());
440
441 LaneAllocInfo allocInfo = {};
442 CreateAllocInfoForAllocTest(LANE_T_MSG, DEFAULT_QOSINFO_MIN_BW + HIGH_BW, DEFAULT_QOSINFO_MAX_LATENCY,
443 DEFAULT_QOSINFO_MIN_LATENCY, &allocInfo);
444 SetIsNeedCondWait();
445 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listener);
446 EXPECT_EQ(ret, SOFTBUS_OK);
447 CondWait();
448 EXPECT_EQ(g_errCode, ERROR_WIFI_OFF);
449
450 (void)laneManager->lnnFreeLane(laneReqId);
451 }
452
453 /*
454 * @tc.name: LANE_ALLOC_Test_001
455 * @tc.desc: lane alloc by select default link for T_MSG (build wlan5g)
456 * @tc.type: FUNC
457 * @tc.require:
458 */
459 HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_001, TestSize.Level1)
460 {
461 const LnnLaneManager *laneManager = GetLaneManager();
462 LaneType laneType = LANE_TYPE_TRANS;
463 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
464 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
465
466 NiceMock<LaneDepsInterfaceMock> mock;
467 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
468 mock.SetDefaultResultForAlloc(1 << BIT_WIFI_5G, 1 << BIT_WIFI_5G, 0, 0);
469 EXPECT_CALL(mock, AddTrigger).WillRepeatedly(LaneDepsInterfaceMock::ActionOfAddTrigger);
470 char buf[] = "lanedetect";
471 EXPECT_CALL(mock, ConnSendSocketData).WillRepeatedly(Return(sizeof(buf)));
472 EXPECT_CALL(mock, DeleteNetworkResourceByLaneId).WillRepeatedly(Return());
473 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
474 wifiMock.SetDefaultResult();
475 SoftBusWifiLinkedInfo wlanInfo;
476 (void)memset_s(&wlanInfo, sizeof(SoftBusWifiLinkedInfo), 0, sizeof(SoftBusWifiLinkedInfo));
477 wlanInfo.connState = SOFTBUS_API_WIFI_CONNECTED;
478 EXPECT_CALL(wifiMock, SoftBusGetLinkedInfo)
479 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM1>(wlanInfo), Return(SOFTBUS_OK)));
480
481 LaneAllocInfo allocInfo = {};
482 CreateAllocInfoForAllocTest(LANE_T_MSG, 0, 0, 0, &allocInfo);
483 SetIsNeedCondWait();
484 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForWlan5g);
485 EXPECT_EQ(ret, SOFTBUS_OK);
486 CondWait();
487 SetIsNeedCondWait();
488 ret = laneManager->lnnFreeLane(laneReqId);
489 EXPECT_EQ(ret, SOFTBUS_OK);
490 CondWait();
491 }
492
493 /*
494 * @tc.name: LANE_ALLOC_Test_002
495 * @tc.desc: lane alloc by select default link for T_BYTE (not enable wlan and br, build ble)
496 * @tc.type: FUNC
497 * @tc.require:
498 */
499 HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_002, 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_BLE, 1 << BIT_BLE, 0, 0);
509 EXPECT_CALL(mock, DeleteNetworkResourceByLaneId).WillRepeatedly(Return());
510 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
511 wifiMock.SetDefaultResult();
512 LaneAllocInfo allocInfo = {};
513 ASSERT_EQ(strncpy_s(allocInfo.extendInfo.peerBleMac, MAX_MAC_LEN,
514 PEER_MAC, strlen(PEER_MAC)), EOK);
515 CreateAllocInfoForAllocTest(LANE_T_BYTE, 0, 0, 0, &allocInfo);
516 SetIsNeedCondWait();
517 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForBle);
518 EXPECT_EQ(ret, SOFTBUS_OK);
519 CondWait();
520 SetIsNeedCondWait();
521 ret = laneManager->lnnFreeLane(laneReqId);
522 EXPECT_EQ(ret, SOFTBUS_OK);
523 CondWait();
524 }
525
526 /*
527 * @tc.name: LANE_ALLOC_Test_003
528 * @tc.desc: lane alloc by select default link for T_FILE (not enable wlan and hml, build p2p)
529 * @tc.type: FUNC
530 * @tc.require:
531 */
532 HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_003, TestSize.Level1)
533 {
534 const LnnLaneManager *laneManager = GetLaneManager();
535 LaneType laneType = LANE_TYPE_TRANS;
536 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
537 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
538
539 NiceMock<LaneDepsInterfaceMock> mock;
540 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
541 mock.SetDefaultResultForAlloc(1 << BIT_WIFI_P2P, 1 << BIT_WIFI_P2P, 0, 0);
542 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
543 EXPECT_CALL(wifiMock, SoftBusGetWifiState).WillRepeatedly(Return(SOFTBUS_WIFI_STATE_ACTIVED));
544 wifiMock.SetDefaultResult();
545 EXPECT_CALL(wifiMock, LnnConnectP2p(NotNull(), laneReqId, NotNull()))
546 .WillRepeatedly(LnnWifiAdpterInterfaceMock::ActionOfLnnConnectP2p);
547
548 LaneAllocInfo allocInfo = {};
549 CreateAllocInfoForAllocTest(LANE_T_FILE, 0, 0, 0, &allocInfo);
550 SetIsNeedCondWait();
551 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForP2p);
552 EXPECT_EQ(ret, SOFTBUS_OK);
553 CondWait();
554 SetIsNeedCondWait();
555 ret = laneManager->lnnFreeLane(laneReqId);
556 EXPECT_EQ(ret, SOFTBUS_OK);
557 CondWait();
558 }
559
560 /*
561 * @tc.name: LANE_ALLOC_Test_004
562 * @tc.desc: lane alloc by select default link for T_RAW_STREAM (not enable wlan, build p2p)
563 * @tc.type: FUNC
564 * @tc.require:
565 */
566 HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_004, TestSize.Level1)
567 {
568 const LnnLaneManager *laneManager = GetLaneManager();
569 LaneType laneType = LANE_TYPE_TRANS;
570 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
571 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
572
573 NiceMock<LaneDepsInterfaceMock> mock;
574 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
575 mock.SetDefaultResultForAlloc(1 << BIT_WIFI_P2P, 1 << BIT_WIFI_P2P, 0, 0);
576 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
577 wifiMock.SetDefaultResult();
578 EXPECT_CALL(wifiMock, LnnConnectP2p(NotNull(), laneReqId, NotNull()))
579 .WillRepeatedly(LnnWifiAdpterInterfaceMock::ActionOfLnnConnectP2p);
580
581 LaneAllocInfo allocInfo = {};
582 CreateAllocInfoForAllocTest(LANE_T_RAW_STREAM, 0, 0, 0, &allocInfo);
583 SetIsNeedCondWait();
584 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForP2p);
585 EXPECT_EQ(ret, SOFTBUS_OK);
586 CondWait();
587 SetIsNeedCondWait();
588 ret = laneManager->lnnFreeLane(laneReqId);
589 EXPECT_EQ(ret, SOFTBUS_OK);
590 CondWait();
591 }
592
593 /*
594 * @tc.name: LANE_ALLOC_Test_005
595 * @tc.desc: lane alloc by mesh link (not enable wlan, build br)
596 * @tc.type: FUNC
597 * @tc.require:
598 */
599 HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_005, TestSize.Level1)
600 {
601 const LnnLaneManager *laneManager = GetLaneManager();
602 LaneType laneType = LANE_TYPE_TRANS;
603 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
604 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
605
606 NiceMock<LaneDepsInterfaceMock> mock;
607 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
608 mock.SetDefaultResultForAlloc(1 << BIT_BR, 1 << BIT_BR, 0, 0);
609 EXPECT_CALL(mock, DeleteNetworkResourceByLaneId).WillRepeatedly(Return());
610 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
611 wifiMock.SetDefaultResult();
612
613 LaneAllocInfo allocInfo = {};
614 CreateAllocInfoForAllocTest(LANE_T_RAW_STREAM, MESH_MAGIC_NUMBER, 0, 0, &allocInfo);
615 SetIsNeedCondWait();
616 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForBr);
617 EXPECT_EQ(ret, SOFTBUS_OK);
618 CondWait();
619 SetIsNeedCondWait();
620 ret = laneManager->lnnFreeLane(laneReqId);
621 EXPECT_EQ(ret, SOFTBUS_OK);
622 CondWait();
623 }
624
625 /*
626 * @tc.name: LANE_ALLOC_Test_006
627 * @tc.desc: lane alloc by RTT link (not enable hml, build p2p)
628 * @tc.type: FUNC
629 * @tc.require:
630 */
631 HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_006, TestSize.Level1)
632 {
633 const LnnLaneManager *laneManager = GetLaneManager();
634 LaneType laneType = LANE_TYPE_TRANS;
635 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
636 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
637
638 NiceMock<LaneDepsInterfaceMock> mock;
639 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
640 mock.SetDefaultResultForAlloc(1 << BIT_WIFI_P2P, 1 << BIT_WIFI_P2P, 0, 0);
641 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
642 wifiMock.SetDefaultResult();
643 EXPECT_CALL(wifiMock, LnnConnectP2p(NotNull(), laneReqId, NotNull()))
644 .WillRepeatedly(LnnWifiAdpterInterfaceMock::ActionOfLnnConnectP2p);
645
646 LaneAllocInfo allocInfo = {};
647 allocInfo.qosRequire.rttLevel = LANE_RTT_LEVEL_LOW;
648 CreateAllocInfoForAllocTest(LANE_T_RAW_STREAM, DEFAULT_QOSINFO_MIN_BW, 0, 0, &allocInfo);
649 SetIsNeedCondWait();
650 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForP2p);
651 EXPECT_EQ(ret, SOFTBUS_OK);
652 CondWait();
653 SetIsNeedCondWait();
654 ret = laneManager->lnnFreeLane(laneReqId);
655 EXPECT_EQ(ret, SOFTBUS_OK);
656 CondWait();
657 }
658
659 /*
660 * @tc.name: LANE_ALLOC_Test_007
661 * @tc.desc: lane alloc by qos require (HIGH_BW, build hml)
662 * @tc.type: FUNC
663 * @tc.require:
664 */
665 HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_007, TestSize.Level1)
666 {
667 const LnnLaneManager *laneManager = GetLaneManager();
668 LaneType laneType = LANE_TYPE_TRANS;
669 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
670 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
671
672 NiceMock<LaneDepsInterfaceMock> mock;
673 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
674 mock.SetDefaultResultForAlloc(NET_CAP, NET_CAP, 1 << BIT_WIFI_DIRECT_ENHANCE_CAPABILITY,
675 1 << BIT_WIFI_DIRECT_ENHANCE_CAPABILITY);
676 EXPECT_CALL(mock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
677 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
678 EXPECT_CALL(wifiMock, SoftBusGetWifiState).WillRepeatedly(Return(SOFTBUS_WIFI_STATE_ACTIVED));
679 wifiMock.SetDefaultResult();
680 EXPECT_CALL(wifiMock, LnnConnectP2p(NotNull(), laneReqId, NotNull()))
681 .WillRepeatedly(LnnWifiAdpterInterfaceMock::ActionOfLnnConnectP2p);
682
683 LaneAllocInfo allocInfo = {};
684 CreateAllocInfoForAllocTest(LANE_T_MSG, DEFAULT_QOSINFO_MIN_BW + HIGH_BW, DEFAULT_QOSINFO_MAX_LATENCY,
685 DEFAULT_QOSINFO_MIN_LATENCY, &allocInfo);
686 SetIsNeedCondWait();
687 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForHml);
688 EXPECT_EQ(ret, SOFTBUS_OK);
689 CondWait();
690 SetIsNeedCondWait();
691 ret = laneManager->lnnFreeLane(laneReqId);
692 EXPECT_EQ(ret, SOFTBUS_OK);
693 CondWait();
694 }
695
696 /*
697 * @tc.name: LANE_ALLOC_Test_008
698 * @tc.desc: lane alloc by qos require (MID_HIGH_BW, not enable hml, build wlan5g)
699 * @tc.type: FUNC
700 * @tc.require:
701 */
702 HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_008, TestSize.Level1)
703 {
704 const LnnLaneManager *laneManager = GetLaneManager();
705 LaneType laneType = LANE_TYPE_TRANS;
706 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
707 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
708
709 NiceMock<LaneDepsInterfaceMock> mock;
710 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
711 mock.SetDefaultResultForAlloc(1 << BIT_WIFI_5G, 1 << BIT_WIFI_5G, 0, 0);
712 EXPECT_CALL(mock, AddTrigger).WillRepeatedly(LaneDepsInterfaceMock::ActionOfAddTrigger);
713 char buf[] = "lanedetect";
714 EXPECT_CALL(mock, ConnSendSocketData).WillRepeatedly(Return(sizeof(buf)));
715 EXPECT_CALL(mock, DeleteNetworkResourceByLaneId).WillRepeatedly(Return());
716 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
717 wifiMock.SetDefaultResult();
718 SoftBusWifiLinkedInfo wlanInfo;
719 (void)memset_s(&wlanInfo, sizeof(SoftBusWifiLinkedInfo), 0, sizeof(SoftBusWifiLinkedInfo));
720 wlanInfo.band = 0;
721 wlanInfo.connState = SOFTBUS_API_WIFI_CONNECTED;
722 EXPECT_CALL(wifiMock, SoftBusGetLinkedInfo)
723 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM1>(wlanInfo), Return(SOFTBUS_OK)));
724
725 LaneAllocInfo allocInfo = {};
726 CreateAllocInfoForAllocTest(LANE_T_MSG, DEFAULT_QOSINFO_MIN_BW + MID_BW, DEFAULT_QOSINFO_MAX_LATENCY,
727 DEFAULT_QOSINFO_MIN_LATENCY, &allocInfo);
728 SetIsNeedCondWait();
729 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForWlan5g);
730 EXPECT_EQ(ret, SOFTBUS_OK);
731 CondWait();
732 SetIsNeedCondWait();
733 ret = laneManager->lnnFreeLane(laneReqId);
734 EXPECT_EQ(ret, SOFTBUS_OK);
735 CondWait();
736 }
737
738 /*
739 * @tc.name: LANE_ALLOC_Test_009
740 * @tc.desc: lane alloc by qos require (MID_LOW_BW, not enable wlan5g and hml, build wlan24g)
741 * @tc.type: FUNC
742 * @tc.require:
743 */
744 HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_009, TestSize.Level1)
745 {
746 const LnnLaneManager *laneManager = GetLaneManager();
747 LaneType laneType = LANE_TYPE_TRANS;
748 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
749 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
750
751 NiceMock<LaneDepsInterfaceMock> mock;
752 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
753 mock.SetDefaultResultForAlloc(1 << BIT_WIFI_5G, 1 << BIT_WIFI_5G, 0, 0);
754 EXPECT_CALL(mock, AddTrigger).WillRepeatedly(LaneDepsInterfaceMock::ActionOfAddTrigger);
755 char buf[] = "lanedetect";
756 EXPECT_CALL(mock, ConnSendSocketData).WillRepeatedly(Return(sizeof(buf)));
757 EXPECT_CALL(mock, DeleteNetworkResourceByLaneId).WillRepeatedly(Return());
758 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
759 wifiMock.SetDefaultResult();
760 SoftBusWifiLinkedInfo wlanInfo;
761 (void)memset_s(&wlanInfo, sizeof(SoftBusWifiLinkedInfo), 0, sizeof(SoftBusWifiLinkedInfo));
762 wlanInfo.band = 1;
763 wlanInfo.connState = SOFTBUS_API_WIFI_CONNECTED;
764 EXPECT_CALL(wifiMock, SoftBusGetLinkedInfo)
765 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM1>(wlanInfo), Return(SOFTBUS_OK)));
766
767 LaneAllocInfo allocInfo = {};
768 CreateAllocInfoForAllocTest(LANE_T_MSG, DEFAULT_QOSINFO_MIN_BW + LOW_BW, DEFAULT_QOSINFO_MAX_LATENCY,
769 DEFAULT_QOSINFO_MIN_LATENCY, &allocInfo);
770 SetIsNeedCondWait();
771 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForWlan5g);
772 EXPECT_EQ(ret, SOFTBUS_OK);
773 CondWait();
774 SetIsNeedCondWait();
775 ret = laneManager->lnnFreeLane(laneReqId);
776 EXPECT_EQ(ret, SOFTBUS_OK);
777 CondWait();
778 }
779
780 /*
781 * @tc.name: LANE_ALLOC_Test_010
782 * @tc.desc: lane alloc by qos require (LOW_BW, not enable wlan5g\hml\br\p2p\coc_direct, build ble)
783 * @tc.type: FUNC
784 * @tc.require:
785 */
786 HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_010, TestSize.Level1)
787 {
788 const LnnLaneManager *laneManager = GetLaneManager();
789 LaneType laneType = LANE_TYPE_TRANS;
790 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
791 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
792
793 NiceMock<LaneDepsInterfaceMock> mock;
794 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
795 mock.SetDefaultResultForAlloc(1 << BIT_BLE, 1 << BIT_BLE, 0, 0);
796 EXPECT_CALL(mock, DeleteNetworkResourceByLaneId).WillRepeatedly(Return());
797 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
798 wifiMock.SetDefaultResult();
799
800 LaneAllocInfo allocInfo = {};
801 ASSERT_EQ(strncpy_s(allocInfo.extendInfo.peerBleMac, MAX_MAC_LEN,
802 PEER_MAC, strlen(PEER_MAC)), EOK);
803 CreateAllocInfoForAllocTest(LANE_T_MSG, LOW_BW - DEFAULT_QOSINFO_MIN_BW, DEFAULT_QOSINFO_MAX_LATENCY,
804 DEFAULT_QOSINFO_MIN_LATENCY, &allocInfo);
805 SetIsNeedCondWait();
806 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForBle);
807 EXPECT_EQ(ret, SOFTBUS_OK);
808 CondWait();
809 SetIsNeedCondWait();
810 ret = laneManager->lnnFreeLane(laneReqId);
811 EXPECT_EQ(ret, SOFTBUS_OK);
812 CondWait();
813 }
814
815 /*
816 * @tc.name: LANE_ALLOC_Test_011
817 * @tc.desc: lane alloc for exception deal before select link
818 * @tc.type: FAILUE
819 * @tc.require:
820 */
821 HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_011, TestSize.Level1)
822 {
823 const LnnLaneManager *laneManager = GetLaneManager();
824 LaneType laneType = LANE_TYPE_TRANS;
825 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
826 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
827
828 NiceMock<LaneDepsInterfaceMock> mock;
829 EXPECT_CALL(mock, LnnGetOnlineStateById).WillRepeatedly(Return(false));
830
831 LaneAllocInfo allocInfo = {};
832 int32_t ret = laneManager->lnnAllocLane(laneReqId, nullptr, &g_listenerCbForP2p);
833 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
834
835 ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, nullptr);
836 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
837
838 allocInfo.type = LANE_TYPE_BUTT;
839 ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForP2p);
840 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
841
842 allocInfo.type = (LaneType)-1;
843 ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForP2p);
844 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
845
846 ret = laneManager->lnnAllocLane(INVALID_LANE_REQ_ID, &allocInfo, &g_listenerCbForP2p);
847 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
848
849 allocInfo.type = LANE_TYPE_HDLC;
850 ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForP2p);
851 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
852
853 allocInfo.type = laneType;
854 ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForP2p);
855 EXPECT_EQ(ret, SOFTBUS_NETWORK_NODE_OFFLINE);
856
857 ret = laneManager->lnnFreeLane(laneReqId);
858 EXPECT_EQ(ret, SOFTBUS_LANE_NOT_FOUND);
859 }
860
861 /*
862 * @tc.name: LANE_ALLOC_Test_012
863 * @tc.desc: lane alloc for continuous task(local is watch)
864 * @tc.type: FUNC
865 * @tc.require:
866 */
867 HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_012, TestSize.Level1)
868 {
869 const LnnLaneManager *laneManager = GetLaneManager();
870 LaneType laneType = LANE_TYPE_TRANS;
871 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
872 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
873
874 NiceMock<LaneDepsInterfaceMock> mock;
875 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
876 mock.SetDefaultResultForAlloc(11, 11, 0x2400, 0x2400);
877 EXPECT_CALL(mock, LnnGetLocalNumInfo)
878 .WillOnce(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(TYPE_WATCH_ID), Return(SOFTBUS_OK)))
879 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(11), Return(SOFTBUS_OK)));
880 EXPECT_CALL(mock, LnnGetRemoteNumInfo)
881 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(11), Return(SOFTBUS_OK)));
882 EXPECT_CALL(mock, DeleteNetworkResourceByLaneId).WillRepeatedly(Return());
883 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
884 wifiMock.SetDefaultResult();
885
886 LaneAllocInfo allocInfo = {};
887 CreateAllocInfoForAllocTest(LANE_T_BYTE, LOW_BW - DEFAULT_QOSINFO_MIN_BW, DEFAULT_QOSINFO_MAX_LATENCY,
888 DEFAULT_QOSINFO_MIN_LATENCY, &allocInfo);
889 allocInfo.qosRequire.continuousTask = true;
890 SetIsNeedCondWait();
891 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForBr);
892 EXPECT_EQ(ret, SOFTBUS_OK);
893 CondWait();
894 SetIsNeedCondWait();
895 ret = laneManager->lnnFreeLane(laneReqId);
896 EXPECT_EQ(ret, SOFTBUS_OK);
897 CondWait();
898 }
899
900 /*
901 * @tc.name: LANE_ALLOC_Test_013
902 * @tc.desc: lane alloc for continuous task(remote is watch)
903 * @tc.type: FUNC
904 * @tc.require:
905 */
906 HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_013, TestSize.Level1)
907 {
908 const LnnLaneManager *laneManager = GetLaneManager();
909 LaneType laneType = LANE_TYPE_TRANS;
910 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
911 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
912
913 NiceMock<LaneDepsInterfaceMock> mock;
914 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
915 mock.SetDefaultResultForAlloc(11, 11, 0x2400, 0x2400);
916 EXPECT_CALL(mock, LnnGetLocalNumInfo)
917 .WillOnce(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(TYPE_PHONE_ID), Return(SOFTBUS_OK)))
918 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(11), Return(SOFTBUS_OK)));
919 EXPECT_CALL(mock, LnnGetRemoteNumInfo)
920 .WillOnce(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(TYPE_WATCH_ID), Return(SOFTBUS_OK)))
921 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(11), Return(SOFTBUS_OK)));
922 EXPECT_CALL(mock, DeleteNetworkResourceByLaneId).WillRepeatedly(Return());
923 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
924 wifiMock.SetDefaultResult();
925
926 LaneAllocInfo allocInfo = {};
927 CreateAllocInfoForAllocTest(LANE_T_BYTE, LOW_BW - DEFAULT_QOSINFO_MIN_BW, DEFAULT_QOSINFO_MAX_LATENCY,
928 DEFAULT_QOSINFO_MIN_LATENCY, &allocInfo);
929 allocInfo.qosRequire.continuousTask = true;
930 SetIsNeedCondWait();
931 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForBr);
932 EXPECT_EQ(ret, SOFTBUS_OK);
933 CondWait();
934 SetIsNeedCondWait();
935 ret = laneManager->lnnFreeLane(laneReqId);
936 EXPECT_EQ(ret, SOFTBUS_OK);
937 CondWait();
938 }
939
940 /*
941 * @tc.name: LANE_ALLOC_Test_014
942 * @tc.desc: lane alloc for MIDDLE_LOW_BW¬ continuous task(local is watch)
943 * @tc.type: FUNC
944 * @tc.require:
945 */
946 HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_014, TestSize.Level1)
947 {
948 const LnnLaneManager *laneManager = GetLaneManager();
949 LaneType laneType = LANE_TYPE_TRANS;
950 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
951 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
952
953 NiceMock<LaneDepsInterfaceMock> mock;
954 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
955 mock.SetDefaultResultForAlloc(15, 15, 0x3137A, 0x3FFEA);
956 EXPECT_CALL(mock, LnnGetLocalNumInfo)
957 .WillOnce(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(TYPE_WATCH_ID), Return(SOFTBUS_OK)))
958 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(11), Return(SOFTBUS_OK)));
959 EXPECT_CALL(mock, LnnGetRemoteNumInfo)
960 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(11), Return(SOFTBUS_OK)));
961 EXPECT_CALL(mock, DeleteNetworkResourceByLaneId).WillRepeatedly(Return());
962 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
963 wifiMock.SetDefaultResult();
964 EXPECT_CALL(wifiMock, LnnConnectP2p(NotNull(), laneReqId, NotNull()))
965 .WillRepeatedly(LnnWifiAdpterInterfaceMock::ActionOfLnnConnectP2p);
966
967 LaneAllocInfo allocInfo = {};
968 CreateAllocInfoForAllocTest(LANE_T_BYTE, DEFAULT_QOSINFO_MIN_BW + LOW_BW, DEFAULT_QOSINFO_MAX_LATENCY,
969 DEFAULT_QOSINFO_MIN_LATENCY, &allocInfo);
970 SetIsNeedCondWait();
971 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForP2p);
972 EXPECT_EQ(ret, SOFTBUS_OK);
973 CondWait();
974 SetIsNeedCondWait();
975 ret = laneManager->lnnFreeLane(laneReqId);
976 EXPECT_EQ(ret, SOFTBUS_OK);
977 CondWait();
978 }
979
980 /*
981 * @tc.name: LANE_ALLOC_Test_015
982 * @tc.desc: lane alloc for MIDDLE_HIGH_BW¬ continuous task(remote is watch)
983 * @tc.type: FUNC
984 * @tc.require:
985 */
986 HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_015, TestSize.Level1)
987 {
988 const LnnLaneManager *laneManager = GetLaneManager();
989 LaneType laneType = LANE_TYPE_TRANS;
990 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
991 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
992
993 NiceMock<LaneDepsInterfaceMock> mock;
994 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
995 mock.SetDefaultResultForAlloc(15, 15, 0x3FFEA, 0x3137A);
996 EXPECT_CALL(mock, LnnGetLocalNumInfo)
997 .WillOnce(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(TYPE_PHONE_ID), Return(SOFTBUS_OK)))
998 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(11), Return(SOFTBUS_OK)));
999 EXPECT_CALL(mock, LnnGetRemoteNumInfo)
1000 .WillOnce(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(TYPE_WATCH_ID), Return(SOFTBUS_OK)))
1001 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(11), Return(SOFTBUS_OK)));
1002 EXPECT_CALL(mock, DeleteNetworkResourceByLaneId).WillRepeatedly(Return());
1003 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1004 wifiMock.SetDefaultResult();
1005 EXPECT_CALL(wifiMock, LnnConnectP2p(NotNull(), laneReqId, NotNull()))
1006 .WillRepeatedly(LnnWifiAdpterInterfaceMock::ActionOfLnnConnectP2p);
1007
1008 LaneAllocInfo allocInfo = {};
1009 CreateAllocInfoForAllocTest(LANE_T_BYTE, HIGH_BW - DEFAULT_QOSINFO_MIN_BW, DEFAULT_QOSINFO_MAX_LATENCY,
1010 DEFAULT_QOSINFO_MIN_LATENCY, &allocInfo);
1011 SetIsNeedCondWait();
1012 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForP2p);
1013 EXPECT_EQ(ret, SOFTBUS_OK);
1014 CondWait();
1015 SetIsNeedCondWait();
1016 ret = laneManager->lnnFreeLane(laneReqId);
1017 EXPECT_EQ(ret, SOFTBUS_OK);
1018 CondWait();
1019 }
1020
1021 /*
1022 * @tc.name: LANE_ALLOC_Test_016
1023 * @tc.desc: lane alloc for continuous task(lowBw and remote is hoos, expect link is br)
1024 * @tc.type: FUNC
1025 * @tc.require:
1026 */
1027 HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_016, TestSize.Level1)
1028 {
1029 const LnnLaneManager *laneManager = GetLaneManager();
1030 LaneType laneType = LANE_TYPE_TRANS;
1031 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
1032 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
1033
1034 NiceMock<LaneDepsInterfaceMock> mock;
1035 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
1036 mock.SetDefaultResultForAlloc(15, 15, 0x3F7EA, 0x3F7EA);
1037 EXPECT_CALL(mock, DeleteNetworkResourceByLaneId).WillRepeatedly(Return());
1038 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1039 wifiMock.SetDefaultResult();
1040
1041 LaneAllocInfo allocInfo = {};
1042 ASSERT_EQ(strncpy_s(allocInfo.extendInfo.peerBleMac, MAX_MAC_LEN,
1043 PEER_MAC, strlen(PEER_MAC)), EOK);
1044 CreateAllocInfoForAllocTest(LANE_T_MSG, LOW_BW - DEFAULT_QOSINFO_MIN_BW, DEFAULT_QOSINFO_MAX_LATENCY,
1045 DEFAULT_QOSINFO_MIN_LATENCY, &allocInfo);
1046 allocInfo.qosRequire.continuousTask = true;
1047 SetIsNeedCondWait();
1048 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForBr);
1049 EXPECT_EQ(ret, SOFTBUS_OK);
1050 CondWait();
1051 SetIsNeedCondWait();
1052 ret = laneManager->lnnFreeLane(laneReqId);
1053 EXPECT_EQ(ret, SOFTBUS_OK);
1054 CondWait();
1055 }
1056
1057 /*
1058 * @tc.name: LANE_RE_ALLOC_Test_001
1059 * @tc.desc: lane re alloc for invalid param
1060 * @tc.type: FUNC
1061 * @tc.require:
1062 */
1063 HWTEST_F(LNNLaneMockTest, LANE_RE_ALLOC_Test_001, TestSize.Level1)
1064 {
1065 const LnnLaneManager *laneManager = GetLaneManager();
1066 LaneType laneType = LANE_TYPE_TRANS;
1067 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
1068 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
1069
1070 int32_t ret = laneManager->lnnReAllocLane(laneReqId, LANE_ID_BASE, nullptr, &g_listenerCbForP2p);
1071 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1072
1073 LaneAllocInfo allocInfo;
1074 ASSERT_EQ(memset_s(&allocInfo, sizeof(LaneAllocInfo), 0, sizeof(LaneAllocInfo)), EOK);
1075 allocInfo.type = LANE_TYPE_BUTT;
1076
1077 ret = laneManager->lnnReAllocLane(laneReqId, LANE_ID_BASE, &allocInfo, nullptr);
1078 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1079
1080 ret = laneManager->lnnReAllocLane(laneReqId, LANE_ID_BASE, &allocInfo, &g_listenerCbForP2p);
1081 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1082
1083 ret = laneManager->lnnReAllocLane(INVALID_LANE_REQ_ID, LANE_ID_BASE, &allocInfo, &g_listenerCbForP2p);
1084 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1085
1086 ret = laneManager->lnnReAllocLane(laneReqId, INVALID_LANE_ID, &allocInfo, &g_listenerCbForP2p);
1087 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1088
1089 allocInfo.type = LANE_TYPE_HDLC;
1090 ret = laneManager->lnnReAllocLane(laneReqId, INVALID_LANE_ID, &allocInfo, &g_listenerCbForP2p);
1091 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1092 }
1093
1094 /*
1095 * @tc.name: LANE_RE_ALLOC_Test_002
1096 * @tc.desc: lane re alloc for MSG HIGH_BW
1097 * @tc.type: FUNC
1098 * @tc.require:
1099 */
1100 HWTEST_F(LNNLaneMockTest, LANE_RE_ALLOC_Test_002, TestSize.Level1)
1101 {
1102 const LnnLaneManager *laneManager = GetLaneManager();
1103 LaneType laneType = LANE_TYPE_TRANS;
1104 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
1105 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
1106
1107 NiceMock<LaneDepsInterfaceMock> mock;
1108 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
1109 mock.SetDefaultResultForAlloc(63, 63, 8, 8);
1110 EXPECT_CALL(mock, DeleteNetworkResourceByLaneId).WillRepeatedly(Return());
1111 EXPECT_CALL(mock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
1112 int32_t ret = AddLaneResourceForAllocTest(LANE_HML);
1113 EXPECT_EQ(ret, SOFTBUS_OK);
1114
1115 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1116 wifiMock.SetDefaultResult();
1117 EXPECT_CALL(wifiMock, LnnConnectP2p(NotNull(), laneReqId, NotNull()))
1118 .WillRepeatedly(LnnWifiAdpterInterfaceMock::ActionOfLnnConnectP2p);
1119
1120 LaneAllocInfo allocInfo;
1121 ASSERT_EQ(memset_s(&allocInfo, sizeof(LaneAllocInfo), 0, sizeof(LaneAllocInfo)), EOK);
1122 CreateAllocInfoForAllocTest(LANE_T_MSG, DEFAULT_QOSINFO_MIN_BW + HIGH_BW, DEFAULT_QOSINFO_MAX_LATENCY,
1123 DEFAULT_QOSINFO_MIN_LATENCY, &allocInfo);
1124 SetIsNeedCondWait();
1125 ret = laneManager->lnnReAllocLane(laneReqId, LANE_ID_BASE, &allocInfo, &g_listenerCbForP2p);
1126 EXPECT_EQ(ret, SOFTBUS_OK);
1127 CondWait();
1128 ret = DelLaneResourceByLaneId(LANE_ID_BASE, false);
1129 EXPECT_EQ(ret, SOFTBUS_OK);
1130 SetIsNeedCondWait();
1131 ret = laneManager->lnnFreeLane(laneReqId);
1132 EXPECT_TRUE(ret == SOFTBUS_OK);
1133 CondWait();
1134 }
1135
1136 /*
1137 * @tc.name: LANE_RE_ALLOC_Test_003
1138 * @tc.desc: lane re alloc for MSG MID_HIGH_BW
1139 * @tc.type: FUNC
1140 * @tc.require:
1141 */
1142 HWTEST_F(LNNLaneMockTest, LANE_RE_ALLOC_Test_003, TestSize.Level1)
1143 {
1144 const LnnLaneManager *laneManager = GetLaneManager();
1145 LaneType laneType = LANE_TYPE_TRANS;
1146 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
1147 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
1148
1149 NiceMock<LaneDepsInterfaceMock> mock;
1150 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
1151 mock.SetDefaultResultForAlloc(63, 63, 1 << BIT_WIFI_DIRECT_ENHANCE_CAPABILITY,
1152 1 << BIT_WIFI_DIRECT_ENHANCE_CAPABILITY);
1153 EXPECT_CALL(mock, AddTrigger).WillRepeatedly(LaneDepsInterfaceMock::ActionOfAddTrigger);
1154 char buf[] = "lanedetect";
1155 EXPECT_CALL(mock, ConnSendSocketData).WillRepeatedly(Return(sizeof(buf)));
1156 EXPECT_CALL(mock, DeleteNetworkResourceByLaneId).WillRepeatedly(Return());
1157 EXPECT_CALL(mock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
1158 int32_t ret = AddLaneResourceForAllocTest(LANE_HML);
1159 EXPECT_EQ(ret, SOFTBUS_OK);
1160
1161 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1162 wifiMock.SetDefaultResult();
1163 SoftBusWifiLinkedInfo wlanInfo;
1164 (void)memset_s(&wlanInfo, sizeof(SoftBusWifiLinkedInfo), 0, sizeof(SoftBusWifiLinkedInfo));
1165 wlanInfo.band = 0;
1166 wlanInfo.connState = SOFTBUS_API_WIFI_CONNECTED;
1167 EXPECT_CALL(wifiMock, SoftBusGetLinkedInfo)
1168 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM1>(wlanInfo), Return(SOFTBUS_OK)));
1169 LaneAllocInfo allocInfo;
1170 ASSERT_EQ(memset_s(&allocInfo, sizeof(LaneAllocInfo), 0, sizeof(LaneAllocInfo)), EOK);
1171 CreateAllocInfoForAllocTest(LANE_T_MSG, DEFAULT_QOSINFO_MIN_BW + MID_BW, DEFAULT_QOSINFO_MAX_LATENCY,
1172 DEFAULT_QOSINFO_MIN_LATENCY, &allocInfo);
1173 SetIsNeedCondWait();
1174 ret = laneManager->lnnReAllocLane(laneReqId, LANE_ID_BASE, &allocInfo, &g_listenerCbForWlan5g);
1175 EXPECT_EQ(ret, SOFTBUS_OK);
1176 CondWait();
1177 ret = DelLaneResourceByLaneId(LANE_ID_BASE, false);
1178 EXPECT_EQ(ret, SOFTBUS_OK);
1179 SetIsNeedCondWait();
1180 ret = laneManager->lnnFreeLane(laneReqId);
1181 EXPECT_TRUE(ret == SOFTBUS_OK);
1182 CondWait();
1183 }
1184
1185 /*
1186 * @tc.name: LANE_RE_ALLOC_Test_004
1187 * @tc.desc: lane re alloc for MSG MID_LOW_BW
1188 * @tc.type: FUNC
1189 * @tc.require:
1190 */
1191 HWTEST_F(LNNLaneMockTest, LANE_RE_ALLOC_Test_004, TestSize.Level1)
1192 {
1193 const LnnLaneManager *laneManager = GetLaneManager();
1194 LaneType laneType = LANE_TYPE_TRANS;
1195 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
1196 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
1197
1198 NiceMock<LaneDepsInterfaceMock> mock;
1199 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
1200 mock.SetDefaultResultForAlloc(NET_CAP, NET_CAP, 1 << BIT_WIFI_DIRECT_ENHANCE_CAPABILITY,
1201 1 << BIT_WIFI_DIRECT_ENHANCE_CAPABILITY);
1202 EXPECT_CALL(mock, DeleteNetworkResourceByLaneId).WillRepeatedly(Return());
1203 EXPECT_CALL(mock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
1204 int32_t ret = AddLaneResourceForAllocTest(LANE_WLAN_5G);
1205 EXPECT_EQ(ret, SOFTBUS_OK);
1206
1207 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1208 EXPECT_CALL(wifiMock, SoftBusGetWifiState).WillRepeatedly(Return(SOFTBUS_WIFI_STATE_ACTIVED));
1209 wifiMock.SetDefaultResult();
1210 EXPECT_CALL(wifiMock, LnnConnectP2p(NotNull(), laneReqId, NotNull()))
1211 .WillRepeatedly(LnnWifiAdpterInterfaceMock::ActionOfLnnConnectP2p);
1212 LaneAllocInfo allocInfo;
1213 ASSERT_EQ(memset_s(&allocInfo, sizeof(LaneAllocInfo), 0, sizeof(LaneAllocInfo)), EOK);
1214 CreateAllocInfoForAllocTest(LANE_T_MSG, DEFAULT_QOSINFO_MIN_BW + LOW_BW, DEFAULT_QOSINFO_MAX_LATENCY,
1215 DEFAULT_QOSINFO_MIN_LATENCY, &allocInfo);
1216 SetIsNeedCondWait();
1217 ret = laneManager->lnnReAllocLane(laneReqId, LANE_ID_BASE, &allocInfo, &g_listenerCbForHml);
1218 EXPECT_EQ(ret, SOFTBUS_OK);
1219 CondWait();
1220 ret = DelLaneResourceByLaneId(LANE_ID_BASE, false);
1221 EXPECT_EQ(ret, SOFTBUS_OK);
1222 SetIsNeedCondWait();
1223 ret = laneManager->lnnFreeLane(laneReqId);
1224 EXPECT_TRUE(ret == SOFTBUS_OK);
1225 CondWait();
1226 }
1227
1228 /*
1229 * @tc.name: LANE_RE_ALLOC_Test_005
1230 * @tc.desc: lane re alloc for MSG LOW_BW
1231 * @tc.type: FUNC
1232 * @tc.require:
1233 */
1234 HWTEST_F(LNNLaneMockTest, LANE_RE_ALLOC_Test_005, TestSize.Level1)
1235 {
1236 const LnnLaneManager *laneManager = GetLaneManager();
1237 LaneType laneType = LANE_TYPE_TRANS;
1238 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
1239 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
1240
1241 NiceMock<LaneDepsInterfaceMock> mock;
1242 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
1243 mock.SetDefaultResultForAlloc(15, 15, 1 << BIT_WIFI_DIRECT_ENHANCE_CAPABILITY,
1244 1 << BIT_WIFI_DIRECT_ENHANCE_CAPABILITY);
1245 EXPECT_CALL(mock, DeleteNetworkResourceByLaneId).WillRepeatedly(Return());
1246 EXPECT_CALL(mock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
1247 int32_t ret = AddLaneResourceForAllocTest(LANE_HML);
1248 EXPECT_EQ(ret, SOFTBUS_OK);
1249
1250 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1251 wifiMock.SetDefaultResult();
1252 LaneAllocInfo allocInfo;
1253 ASSERT_EQ(memset_s(&allocInfo, sizeof(LaneAllocInfo), 0, sizeof(LaneAllocInfo)), EOK);
1254 CreateAllocInfoForAllocTest(LANE_T_MSG, LOW_BW - DEFAULT_QOSINFO_MIN_BW, DEFAULT_QOSINFO_MAX_LATENCY,
1255 DEFAULT_QOSINFO_MIN_LATENCY, &allocInfo);
1256 SetIsNeedCondWait();
1257 ret = laneManager->lnnReAllocLane(laneReqId, LANE_ID_BASE, &allocInfo, &g_listenerCbForBr);
1258 EXPECT_EQ(ret, SOFTBUS_OK);
1259 CondWait();
1260 ret = DelLaneResourceByLaneId(LANE_ID_BASE, false);
1261 EXPECT_EQ(ret, SOFTBUS_OK);
1262 SetIsNeedCondWait();
1263 ret = laneManager->lnnFreeLane(laneReqId);
1264 EXPECT_TRUE(ret == SOFTBUS_OK);
1265 CondWait();
1266 }
1267
1268 /*
1269 * @tc.name: LANE_CANCEL_Test_001
1270 * @tc.desc: lane cancel after notify
1271 * @tc.type: FUNC
1272 * @tc.require:
1273 */
1274 HWTEST_F(LNNLaneMockTest, LANE_CANCEL_Test_001, TestSize.Level1)
1275 {
1276 const LnnLaneManager *laneManager = GetLaneManager();
1277 LaneType laneType = LANE_TYPE_TRANS;
1278 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
1279 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
1280
1281 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1282 wifiMock.SetDefaultResult();
1283 EXPECT_CALL(wifiMock, LnnConnectP2p(NotNull(), laneReqId, NotNull()))
1284 .WillRepeatedly(LnnWifiAdpterInterfaceMock::ActionOfLnnConnectP2p);
1285 EXPECT_CALL(wifiMock, LnnCancelWifiDirect).WillRepeatedly(Return());
1286 NiceMock<LaneDepsInterfaceMock> mock;
1287 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
1288 mock.SetDefaultResultForAlloc(63, 63, 0, 0);
1289
1290 LaneAllocInfo allocInfo;
1291 ASSERT_EQ(memset_s(&allocInfo, sizeof(LaneAllocInfo), 0, sizeof(LaneAllocInfo)), EOK);
1292 CreateAllocInfoForAllocTest(LANE_T_MSG, DEFAULT_QOSINFO_MIN_BW + HIGH_BW, DEFAULT_QOSINFO_MAX_LATENCY,
1293 DEFAULT_QOSINFO_MIN_LATENCY, &allocInfo);
1294 SetIsNeedCondWait();
1295 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForP2p);
1296 EXPECT_EQ(ret, SOFTBUS_OK);
1297 CondWait();
1298 ret = laneManager->lnnCancelLane(laneReqId);
1299 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1300 SetIsNeedCondWait();
1301 ret = laneManager->lnnFreeLane(laneReqId);
1302 EXPECT_TRUE(ret == SOFTBUS_OK);
1303 CondWait();
1304 }
1305
1306 /*
1307 * @tc.name: LANE_CANCEL_Test_002
1308 * @tc.desc: lane cancel before notify
1309 * @tc.type: FUNC
1310 * @tc.require:
1311 */
1312 HWTEST_F(LNNLaneMockTest, LANE_CANCEL_Test_002, TestSize.Level1)
1313 {
1314 const LnnLaneManager *laneManager = GetLaneManager();
1315 LaneType laneType = LANE_TYPE_TRANS;
1316 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
1317 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
1318
1319 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1320 LnnWifiAdpterInterfaceMock::delayNotifyLinkSuccess = true;
1321 wifiMock.SetDefaultResult();
1322 EXPECT_CALL(wifiMock, LnnConnectP2p(NotNull(), laneReqId, NotNull()))
1323 .WillRepeatedly(LnnWifiAdpterInterfaceMock::ActionOfLnnConnectP2p);
1324 EXPECT_CALL(wifiMock, LnnCancelWifiDirect).WillRepeatedly(Return());
1325 NiceMock<LaneDepsInterfaceMock> mock;
1326 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
1327 mock.SetDefaultResultForAlloc(63, 63, 0, 0);
1328
1329 LaneAllocInfo allocInfo;
1330 ASSERT_EQ(memset_s(&allocInfo, sizeof(LaneAllocInfo), 0, sizeof(LaneAllocInfo)), EOK);
1331 CreateAllocInfoForAllocTest(LANE_T_MSG, DEFAULT_QOSINFO_MIN_BW + HIGH_BW, DEFAULT_QOSINFO_MAX_LATENCY,
1332 DEFAULT_QOSINFO_MIN_LATENCY, &allocInfo);
1333 SetIsNeedCondWait();
1334 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForP2p);
1335 EXPECT_EQ(ret, SOFTBUS_OK);
1336 ret = laneManager->lnnCancelLane(laneReqId);
1337 EXPECT_EQ(ret, SOFTBUS_OK);
1338 CondWait();
1339 LnnWifiAdpterInterfaceMock::delayNotifyLinkSuccess = false;
1340 std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_FOR_LOOP_COMPLETION_MS));
1341 }
1342
1343 /*
1344 * @tc.name: LANE_CANCEL_Test_003
1345 * @tc.desc: lane cancel after free
1346 * @tc.type: FUNC
1347 * @tc.require:
1348 */
1349 HWTEST_F(LNNLaneMockTest, LANE_CANCEL_Test_003, TestSize.Level1)
1350 {
1351 const LnnLaneManager *laneManager = GetLaneManager();
1352 LaneType laneType = LANE_TYPE_TRANS;
1353 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
1354 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
1355
1356 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1357 wifiMock.SetDefaultResult();
1358 EXPECT_CALL(wifiMock, LnnConnectP2p(NotNull(), laneReqId, NotNull()))
1359 .WillRepeatedly(LnnWifiAdpterInterfaceMock::ActionOfLnnConnectP2p);
1360 EXPECT_CALL(wifiMock, LnnCancelWifiDirect).WillRepeatedly(Return());
1361 NiceMock<LaneDepsInterfaceMock> mock;
1362 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
1363 mock.SetDefaultResultForAlloc(63, 63, 0, 0);
1364
1365 LaneAllocInfo allocInfo;
1366 ASSERT_EQ(memset_s(&allocInfo, sizeof(LaneAllocInfo), 0, sizeof(LaneAllocInfo)), EOK);
1367 CreateAllocInfoForAllocTest(LANE_T_MSG, DEFAULT_QOSINFO_MIN_BW + HIGH_BW, DEFAULT_QOSINFO_MAX_LATENCY,
1368 DEFAULT_QOSINFO_MIN_LATENCY, &allocInfo);
1369 SetIsNeedCondWait();
1370 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForP2p);
1371 EXPECT_EQ(ret, SOFTBUS_OK);
1372 CondWait();
1373 SetIsNeedCondWait();
1374 ret = laneManager->lnnFreeLane(laneReqId);
1375 EXPECT_EQ(ret, SOFTBUS_OK);
1376 CondWait();
1377 ret = laneManager->lnnCancelLane(laneReqId);
1378 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1379 }
1380
1381 /*
1382 * @tc.name: LANE_FREE_001
1383 * @tc.desc: lane free
1384 * @tc.type: FUNC
1385 * @tc.require:
1386 */
1387 HWTEST_F(LNNLaneMockTest, LANE_FREE_001, TestSize.Level1)
1388 {
1389 const LnnLaneManager *laneManager = GetLaneManager();
1390 LaneType laneType = LANE_TYPE_BUTT;
1391 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
1392 int32_t ret = laneManager->lnnFreeLane(laneReqId);
1393 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1394
1395 laneType = LANE_TYPE_TRANS;
1396 laneReqId = laneManager->lnnGetLaneHandle(laneType);
1397 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
1398 ret = laneManager->lnnFreeLane(laneReqId);
1399 EXPECT_EQ(ret, SOFTBUS_LANE_NOT_FOUND);
1400 ret = laneManager->lnnFreeLane(laneReqId);
1401 EXPECT_EQ(ret, SOFTBUS_LANE_NOT_FOUND);
1402 }
1403
1404 /*
1405 * @tc.name: LNN_BUILD_LINK_001
1406 * @tc.desc: BUILDLINK
1407 * @tc.type: FUNC
1408 * @tc.require:
1409 */
1410 HWTEST_F(LNNLaneMockTest, LNN_BUILD_LINK_001, TestSize.Level1)
1411 {
1412 LinkRequest reqInfo = {};
1413 reqInfo.linkType = LANE_P2P;
1414 LaneLinkCb cb = {
1415 .onLaneLinkSuccess = OnLaneLinkSuccess,
1416 .onLaneLinkFail = OnLaneLinkFail,
1417 };
1418 int32_t ret;
1419 NiceMock<LaneDepsInterfaceMock> mock;
1420 EXPECT_CALL(mock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
1421 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1422 EXPECT_CALL(wifiMock, LnnDisconnectP2p).WillRepeatedly(Return(SOFTBUS_OK));
1423 EXPECT_CALL(wifiMock, LnnConnectP2p)
1424 .WillOnce(Return(SOFTBUS_LANE_BUILD_LINK_FAIL))
1425 .WillRepeatedly(Return(SOFTBUS_OK));
1426 ret = BuildLink(&reqInfo, 0, &cb);
1427 EXPECT_EQ(ret, SOFTBUS_LANE_BUILD_LINK_FAIL);
1428
1429 ret = BuildLink(&reqInfo, 0, &cb);
1430 EXPECT_TRUE(ret == SOFTBUS_OK);
1431
1432 cb.onLaneLinkFail = nullptr;
1433 ret = BuildLink(&reqInfo, 0, &cb);
1434 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1435
1436 cb.onLaneLinkSuccess = nullptr;
1437 ret = BuildLink(&reqInfo, 0, &cb);
1438 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1439
1440 ret = BuildLink(&reqInfo, 0, nullptr);
1441 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1442
1443 reqInfo.linkType = LANE_BLE;
1444 ret = BuildLink(&reqInfo, 0, nullptr);
1445 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1446
1447 reqInfo.linkType = LANE_LINK_TYPE_BUTT;
1448 ret = BuildLink(&reqInfo, 0, &cb);
1449 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1450
1451 ret = BuildLink(nullptr, 0, nullptr);
1452 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1453
1454 ret = DestroyLink(NODE_NETWORK_ID, 0, LANE_BLE);
1455 EXPECT_TRUE(ret == SOFTBUS_OK);
1456
1457 EXPECT_CALL(wifiMock, LnnDestroyP2p).WillRepeatedly(Return());
1458 ret = DestroyLink(NODE_NETWORK_ID, 0, LANE_P2P);
1459 EXPECT_TRUE(ret == SOFTBUS_OK);
1460 ret = DestroyLink(nullptr, 0, LANE_P2P);
1461 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1462 }
1463
1464 /*
1465 * @tc.name: LNN_BUILD_LINK_002
1466 * @tc.desc: BUILDLINK
1467 * @tc.type: FUNC
1468 * @tc.require:
1469 */
1470 HWTEST_F(LNNLaneMockTest, LNN_BUILD_LINK_002, TestSize.Level1)
1471 {
1472 NiceMock<LaneDepsInterfaceMock> mock;
1473 LinkRequest reqInfo = {};
1474 reqInfo.linkType = LANE_P2P;
1475 LaneLinkCb cb = {
1476 .onLaneLinkSuccess = OnLaneLinkSuccess,
1477 .onLaneLinkFail = OnLaneLinkFail,
1478 };
1479 int32_t ret;
1480 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1481 const char *udid = "testuuid";
1482 EXPECT_CALL(mock, LnnGetRemoteStrInfo).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
1483 ret = BuildLink(&reqInfo, 0, &cb);
1484 EXPECT_TRUE(ret == SOFTBUS_OK);
1485 EXPECT_CALL(mock, LnnConvertDLidToUdid).WillRepeatedly(Return(udid));
1486 EXPECT_CALL(mock, ConnBleGetClientConnectionByUdid).WillRepeatedly(Return(nullptr));
1487 EXPECT_CALL(mock, LnnGetRemoteNodeInfoById).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
1488 ON_CALL(wifiMock, LnnConnectP2p).WillByDefault(Return(SOFTBUS_LANE_BUILD_LINK_FAIL));
1489 ret = BuildLink(&reqInfo, 0, &cb);
1490 EXPECT_EQ(ret, SOFTBUS_LANE_BUILD_LINK_FAIL);
1491 }
1492
1493 /*
1494 * @tc.name: LNN_BUILD_LINK_003
1495 * @tc.desc: BUILDLINK
1496 * @tc.type: FUNC
1497 * @tc.require:
1498 */
1499 HWTEST_F(LNNLaneMockTest, LNN_BUILD_LINK_003, TestSize.Level1)
1500 {
1501 NiceMock<LaneDepsInterfaceMock> mock;
1502 LinkRequest reqInfo = {};
1503 reqInfo.linkType = LANE_P2P;
1504 LaneLinkCb cb = {
1505 .onLaneLinkSuccess = OnLaneLinkSuccess,
1506 .onLaneLinkFail = OnLaneLinkFail,
1507 };
1508 int32_t ret;
1509 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1510
1511 ConnBleConnection *connection = (ConnBleConnection*)SoftBusCalloc(sizeof(ConnBleConnection));
1512 ASSERT_NE(connection, nullptr);
1513 const char *udid = "testuuid";
1514 NodeInfo *nodeInfo = (NodeInfo*)SoftBusCalloc(sizeof(NodeInfo));
1515 if (nodeInfo == nullptr) {
1516 SoftBusFree(connection);
1517 ASSERT_NE(nodeInfo, nullptr);
1518 }
1519 connection->state = BLE_CONNECTION_STATE_EXCHANGED_BASIC_INFO;
1520 EXPECT_CALL(mock, LnnConvertDLidToUdid).WillRepeatedly(Return(udid));
1521 EXPECT_CALL(mock, ConnBleGetClientConnectionByUdid).WillRepeatedly(Return(connection));
1522 EXPECT_CALL(mock, LnnGetRemoteNodeInfoById).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
1523 EXPECT_CALL(wifiMock, LnnConnectP2p).WillRepeatedly(Return(SOFTBUS_OK));
1524 EXPECT_CALL(mock, LnnGetLocalNodeInfo).WillRepeatedly(Return(nodeInfo));
1525 ret = BuildLink(&reqInfo, 0, &cb);
1526 EXPECT_TRUE(ret == SOFTBUS_OK);
1527 SoftBusFree(connection);
1528 SoftBusFree(nodeInfo);
1529 }
1530
1531 /*
1532 * @tc.name: LNN_BUILD_LINK_004
1533 * @tc.desc: BUILDLINK
1534 * @tc.type: FUNC
1535 * @tc.require:
1536 */
1537 HWTEST_F(LNNLaneMockTest, LNN_BUILD_LINK_004, TestSize.Level1)
1538 {
1539 NiceMock<LaneDepsInterfaceMock> mock;
1540 LinkRequest reqInfo = {};
1541 int32_t ret;
1542 const char *udid = "testuuid";
1543 LaneLinkCb cb = {
1544 .onLaneLinkSuccess = OnLaneLinkSuccess,
1545 .onLaneLinkFail = OnLaneLinkFail,
1546 };
1547
1548 reqInfo.linkType = LANE_BLE;
1549 EXPECT_CALL(mock, LnnConvertDLidToUdid).WillRepeatedly(Return(udid));
1550 EXPECT_CALL(mock, ConnBleGetClientConnectionByUdid).WillRepeatedly(Return(nullptr));
1551 ON_CALL(mock, LnnGetRemoteStrInfo).WillByDefault(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
1552 ret = BuildLink(&reqInfo, 0, &cb);
1553 EXPECT_NE(ret, SOFTBUS_OK);
1554
1555 EXPECT_CALL(mock, LnnGetRemoteStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
1556 ON_CALL(mock, SoftBusGenerateStrHash).WillByDefault(Return(SOFTBUS_ENCRYPT_ERR));
1557 ret = BuildLink(&reqInfo, 0, &cb);
1558 EXPECT_NE(ret, SOFTBUS_OK);
1559 ret = BuildLink(&reqInfo, 0, &cb);
1560 EXPECT_NE(ret, SOFTBUS_OK);
1561 }
1562
1563 /*
1564 * @tc.name: LNN_BUILD_LINK_005
1565 * @tc.desc: BUILDLINK
1566 * @tc.type: FUNC
1567 * @tc.require:
1568 */
1569 HWTEST_F(LNNLaneMockTest, LNN_BUILD_LINK_005, TestSize.Level1)
1570 {
1571 NiceMock<LaneDepsInterfaceMock> mock;
1572 LinkRequest reqInfo = {};
1573 int32_t ret;
1574 const char *udid = "testuuid";
1575 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1576 LaneLinkCb cb = {
1577 .onLaneLinkSuccess = OnLaneLinkSuccess,
1578 .onLaneLinkFail = OnLaneLinkFail,
1579 };
1580
1581 reqInfo.linkType = LANE_BLE;
1582 ConnBleConnection *connection = (ConnBleConnection *)SoftBusCalloc(sizeof(ConnBleConnection));
1583 if (connection == nullptr) {
1584 return;
1585 }
1586 connection->state = BLE_CONNECTION_STATE_INVALID;
1587 EXPECT_CALL(mock, LnnConvertDLidToUdid).WillRepeatedly(Return(udid));
1588 EXPECT_CALL(mock, ConnBleGetClientConnectionByUdid).WillRepeatedly(Return(connection));
1589 EXPECT_CALL(mock, LnnGetRemoteStrInfo).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
1590 ON_CALL(mock, LnnGetRemoteNodeInfoById).WillByDefault(Return(SOFTBUS_OK));
1591 ret = BuildLink(&reqInfo, 0, &cb);
1592 EXPECT_TRUE(ret == SOFTBUS_LANE_GET_LEDGER_INFO_ERR);
1593 SoftBusFree(connection);
1594 }
1595
1596 /*
1597 * @tc.name: LNN_BUILD_LINK_006
1598 * @tc.desc: BUILDLINK
1599 * @tc.type: FUNC
1600 * @tc.require:
1601 */
1602 HWTEST_F(LNNLaneMockTest, LNN_BUILD_LINK_006, TestSize.Level1)
1603 {
1604 uint32_t reqId = 0;
1605 const char *networkId = "testnetworkid123";
1606 const char *networkIdNotFound = "testnetworkid133";
1607 const char *ipAddr = "127.0.0.1";
1608 const char *ipAddrDiff = "127.0.0.2";
1609 uint16_t portA = 22;
1610 uint16_t portB = 33;
1611 LaneLinkCb cb = {
1612 .onLaneLinkSuccess = OnLaneLinkSuccess,
1613 .onLaneLinkFail = OnLaneLinkFail,
1614 };
1615 NiceMock<LaneDepsInterfaceMock> mock;
1616 EXPECT_CALL(mock, LnnGetRemoteStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
1617 LinkRequest *request = (LinkRequest *)SoftBusCalloc(sizeof(LinkRequest));
1618 if (request == nullptr) {
1619 return;
1620 }
1621 LaneAddP2pAddress(networkId, ipAddr, portA);
1622 LaneAddP2pAddress(networkId, ipAddr, portB);
1623 LaneAddP2pAddressByIp(ipAddr, portB);
1624 LaneAddP2pAddressByIp(ipAddrDiff, portB);
1625 request->linkType = LANE_P2P_REUSE;
1626 (void)strcpy_s(request->peerNetworkId, NETWORK_ID_BUF_LEN, networkId);
1627 int32_t ret = BuildLink(request, reqId, &cb);
1628 EXPECT_TRUE(ret == SOFTBUS_OK);
1629
1630 (void)strcpy_s(request->peerNetworkId, NETWORK_ID_BUF_LEN, networkIdNotFound);
1631 ret = BuildLink(request, reqId, &cb);
1632 EXPECT_TRUE(ret == SOFTBUS_LANE_NOT_FOUND);
1633 SoftBusFree(request);
1634 LaneDeleteP2pAddress(networkId, true);
1635 }
1636
1637 /*
1638 * @tc.name: LNN_BUILD_LINK_007
1639 * @tc.desc: BUILDLINK
1640 * @tc.type: FUNC
1641 * @tc.require:
1642 */
1643 HWTEST_F(LNNLaneMockTest, LNN_BUILD_LINK_007, TestSize.Level1)
1644 {
1645 NiceMock<LaneDepsInterfaceMock> mock;
1646 uint32_t reqId = 0;
1647 LaneLinkCb cb = {
1648 .onLaneLinkSuccess = OnLaneLinkSuccess,
1649 .onLaneLinkFail = OnLaneLinkFail,
1650 };
1651 LinkRequest *request = (LinkRequest *)SoftBusCalloc(sizeof(LinkRequest));
1652 if (request == nullptr) {
1653 return;
1654 }
1655 NodeInfo *nodeInfo = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
1656 if (nodeInfo == nullptr) {
1657 SoftBusFree(request);
1658 return;
1659 }
1660 request->linkType = LANE_BLE_DIRECT;
1661 EXPECT_CALL(mock, LnnGetRemoteStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
1662 EXPECT_CALL(mock, LnnGetLocalNodeInfo).WillRepeatedly(Return(nodeInfo));
1663
1664 int32_t ret = BuildLink(request, reqId, &cb);
1665 ret = BuildLink(request, reqId, &cb);
1666 EXPECT_TRUE(ret == SOFTBUS_OK);
1667 SoftBusFree(request);
1668 SoftBusFree(nodeInfo);
1669 }
1670
1671 /*
1672 * @tc.name: LNN_BUILD_LINK_008
1673 * @tc.desc: BUILDLINK
1674 * @tc.type: FUNC
1675 * @tc.require:
1676 */
1677 HWTEST_F(LNNLaneMockTest, LNN_BUILD_LINK_008, TestSize.Level1)
1678 {
1679 NiceMock<LaneDepsInterfaceMock> mock;
1680 LinkRequest reqInfo = {};
1681 int32_t ret;
1682 const char *udid = "testuuid";
1683 const char *bleMac = "127.1.1.1";
1684 LaneLinkCb cb = {
1685 .onLaneLinkSuccess = OnLaneLinkSuccess,
1686 .onLaneLinkFail = OnLaneLinkFail,
1687 };
1688
1689 reqInfo.linkType = LANE_COC;
1690 if (strcpy_s(reqInfo.peerBleMac, MAX_MAC_LEN, bleMac) != EOK) {
1691 return;
1692 }
1693 EXPECT_CALL(mock, LnnConvertDLidToUdid).WillRepeatedly(Return(udid));
1694 EXPECT_CALL(mock, ConnBleGetClientConnectionByUdid).WillRepeatedly(Return(nullptr));
1695 EXPECT_CALL(mock, LnnGetRemoteStrInfo).WillOnce(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
1696 ret = BuildLink(&reqInfo, 0, &cb);
1697 EXPECT_EQ(ret, SOFTBUS_LANE_GET_LEDGER_INFO_ERR);
1698
1699 EXPECT_CALL(mock, LnnGetRemoteStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
1700 EXPECT_CALL(mock, SoftBusGenerateStrHash)
1701 .WillOnce(Return(SOFTBUS_ENCRYPT_ERR))
1702 .WillRepeatedly(LaneDepsInterfaceMock::ActionOfGenerateStrHash);
1703 ret = BuildLink(&reqInfo, 0, &cb);
1704 EXPECT_EQ(ret, SOFTBUS_ENCRYPT_ERR);
1705 ret = BuildLink(&reqInfo, 0, &cb);
1706 EXPECT_TRUE(ret == SOFTBUS_OK);
1707 }
1708
1709 /*
1710 * @tc.name: LNN_BUILD_LINK_009
1711 * @tc.desc: BUILDLINK
1712 * @tc.type: FUNC
1713 * @tc.require:
1714 */
1715 HWTEST_F(LNNLaneMockTest, LNN_BUILD_LINK_009, TestSize.Level1)
1716 {
1717 uint32_t reqId = 0;
1718 const char *networkId = "testnetworkid123";
1719 const char *networkIdNotFound = "testnetworkid133";
1720 LaneLinkCb cb = {
1721 .onLaneLinkSuccess = OnLaneLinkSuccess,
1722 .onLaneLinkFail = OnLaneLinkFail,
1723 };
1724 NiceMock<LaneDepsInterfaceMock> mock;
1725 EXPECT_CALL(mock, LnnGetRemoteStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
1726 LinkRequest request = {
1727 .linkType = LANE_COC_DIRECT,
1728 };
1729 ASSERT_EQ(strcpy_s(request.peerNetworkId, NETWORK_ID_BUF_LEN, networkId), EOK);
1730 int32_t ret = BuildLink(&request, reqId, &cb);
1731 EXPECT_TRUE(ret == SOFTBUS_OK);
1732
1733 ASSERT_EQ(strcpy_s(request.peerNetworkId, NETWORK_ID_BUF_LEN, networkIdNotFound), EOK);
1734 ret = BuildLink(&request, reqId, &cb);
1735 EXPECT_TRUE(ret == SOFTBUS_OK);
1736 LaneDeleteP2pAddress(networkId, true);
1737 }
1738
1739 /*
1740 * @tc.name: LNN_BUILD_LINK_010
1741 * @tc.desc: BUILDLINK
1742 * @tc.type: FUNC
1743 * @tc.require:
1744 */
1745 HWTEST_F(LNNLaneMockTest, LNN_BUILD_LINK_010, TestSize.Level1)
1746 {
1747 const char *networkId = "testnetworkid123";
1748 const char *ipAddr = "127.0.0.1";
1749 uint16_t port = 1022;
1750 NiceMock<LaneDepsInterfaceMock> mock;
1751 LinkRequest reqInfo = {};
1752 int32_t ret;
1753 const char *udid = "testuuid";
1754 const char *bleMac = "127.1.1.1";
1755 LaneLinkCb cb = {
1756 .onLaneLinkSuccess = OnLaneLinkSuccess,
1757 .onLaneLinkFail = OnLaneLinkFail,
1758 };
1759 ConnBleConnection *connection = (ConnBleConnection *)SoftBusCalloc(sizeof(ConnBleConnection));
1760 ASSERT_NE(connection, nullptr);
1761 connection->state = BLE_CONNECTION_STATE_EXCHANGED_BASIC_INFO;
1762 reqInfo.linkType = LANE_BLE_REUSE;
1763 int32_t res = strcpy_s(reqInfo.peerBleMac, MAX_MAC_LEN, bleMac);
1764 if (res != EOK) {
1765 SoftBusFree(connection);
1766 ASSERT_EQ(res, EOK);
1767 }
1768 LaneAddP2pAddress(networkId, ipAddr, port);
1769 LaneAddP2pAddressByIp(ipAddr, port);
1770 LaneUpdateP2pAddressByIp(ipAddr, networkId);
1771 ON_CALL(mock, ConnBleGetConnectionByUdid).WillByDefault(Return(connection));
1772 ON_CALL(mock, ConnBleReturnConnection).WillByDefault(Return());
1773 EXPECT_CALL(mock, LnnConvertDLidToUdid).WillRepeatedly(Return(udid));
1774 EXPECT_CALL(mock, SoftBusGenerateStrHash).WillRepeatedly(Return(SOFTBUS_OK));
1775 EXPECT_CALL(mock, LnnGetRemoteStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
1776 ret = BuildLink(&reqInfo, 0, &cb);
1777 EXPECT_TRUE(ret == SOFTBUS_OK);
1778
1779 EXPECT_CALL(mock, ConnBleGetConnectionByUdid).WillRepeatedly(Return(connection));
1780 ret = BuildLink(&reqInfo, 0, &cb);
1781 EXPECT_TRUE(ret == SOFTBUS_OK);
1782 SoftBusFree(connection);
1783 }
1784
1785 /*
1786 * @tc.name: LNN_BUILD_LINK_SLE_001
1787 * @tc.desc: BUILDLINK
1788 * @tc.type: FUNC
1789 * @tc.require:
1790 */
1791 HWTEST_F(LNNLaneMockTest, LNN_BUILD_LINK_SLE_001, TestSize.Level1)
1792 {
1793 NiceMock<LaneDepsInterfaceMock> mock;
1794 LinkRequest reqInfo = {};
1795 LaneLinkCb cb = {
1796 .onLaneLinkSuccess = OnLaneLinkSuccess,
1797 .onLaneLinkFail = OnLaneLinkFail,
1798 };
1799 reqInfo.linkType = LANE_SLE;
1800
1801 EXPECT_CALL(mock, LnnGetRemoteStrInfo)
1802 .WillOnce(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR))
1803 .WillRepeatedly(Return(SOFTBUS_OK));
1804
1805 int32_t ret = BuildLink(&reqInfo, 0, &cb);
1806 EXPECT_NE(ret, SOFTBUS_OK);
1807
1808 ret = BuildLink(&reqInfo, 0, &cb);
1809 EXPECT_EQ(ret, SOFTBUS_LANE_GET_LEDGER_INFO_ERR);
1810
1811 ASSERT_EQ(strncpy_s(reqInfo.peerSleMac, MAX_MAC_LEN,
1812 PEER_MAC, strlen(PEER_MAC)), EOK);
1813 EXPECT_CALL(mock, SoftBusGenerateStrHash)
1814 .WillOnce(Return(SOFTBUS_ENCRYPT_ERR))
1815 .WillRepeatedly(Return(SOFTBUS_OK));
1816
1817 ret = BuildLink(&reqInfo, 0, &cb);
1818 EXPECT_NE(ret, SOFTBUS_OK);
1819
1820 ret = BuildLink(&reqInfo, 0, &cb);
1821 EXPECT_EQ(ret, SOFTBUS_OK);
1822 }
1823
1824 /*
1825 * @tc.name: LNN_BUILD_LINK_SLE_DIRECT_001
1826 * @tc.desc: BUILDLINK
1827 * @tc.type: FUNC
1828 * @tc.require:
1829 */
1830 HWTEST_F(LNNLaneMockTest, LNN_BUILD_LINK_SLE_DIRECT_001, TestSize.Level1)
1831 {
1832 NiceMock<LaneDepsInterfaceMock> mock;
1833 LinkRequest reqInfo = {};
1834 LaneLinkCb cb = {
1835 .onLaneLinkSuccess = OnLaneLinkSuccess,
1836 .onLaneLinkFail = OnLaneLinkFail,
1837 };
1838 reqInfo.linkType = LANE_SLE_DIRECT;
1839
1840 EXPECT_CALL(mock, LnnGetRemoteStrInfo)
1841 .WillOnce(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR))
1842 .WillRepeatedly(Return(SOFTBUS_OK));
1843
1844 int32_t ret = BuildLink(&reqInfo, 0, &cb);
1845 EXPECT_NE(ret, SOFTBUS_OK);
1846
1847 ret = BuildLink(&reqInfo, 0, &cb);
1848 EXPECT_EQ(ret, SOFTBUS_OK);
1849 }
1850
1851 /*
1852 * @tc.name: LANE_FLOAD_EXPLORE_001
1853 * @tc.desc: LANE FLOAD EXPLORE TEST
1854 * @tc.type: FUNC
1855 * @tc.require:
1856 */
1857 HWTEST_F(LNNLaneMockTest, LANE_FLOAD_EXPLORE_001, TestSize.Level1)
1858 {
1859 LaneResource resourceItem = {};
1860 resourceItem.clientRef = DEFAULT_LANE_RESOURCE_LANE_REF;
1861 int32_t ret = LaneDetectFload(&resourceItem);
1862 EXPECT_EQ(ret, SOFTBUS_OK);
1863 }
1864
1865 /*
1866 * @tc.name: LANE_DETECT_RELIABILITY_001
1867 * @tc.desc: LANE DETECT RELIABILITY TEST
1868 * @tc.type: FUNC
1869 * @tc.require:
1870 */
1871 HWTEST_F(LNNLaneMockTest, LANE_DETECT_RELIABILITY_001, TestSize.Level1)
1872 {
1873 LaneLinkCb cb = {
1874 .onLaneLinkSuccess = OnLaneLinkSuccess,
1875 .onLaneLinkFail = OnLaneLinkFail,
1876 };
1877
1878 NiceMock<LaneDepsInterfaceMock> mock;
1879 EXPECT_CALL(mock, ConnOpenClientSocket).WillRepeatedly(Return(SOFTBUS_OK));
1880 EXPECT_CALL(mock, AddTrigger).WillRepeatedly(Return(SOFTBUS_OK));
1881
1882 LaneLinkInfo linkInfo;
1883 linkInfo.type = LANE_WLAN_2P4G;
1884 const LnnLaneManager *laneManager = GetLaneManager();
1885 LaneType laneType = LANE_TYPE_TRANS;
1886 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
1887 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
1888
1889 uint64_t laneId = LANE_ID_BASE;
1890 int32_t ret = AddLaneResourceToPool(&linkInfo, laneId, false);
1891 EXPECT_EQ(ret, SOFTBUS_OK);
1892
1893 ret = LaneDetectReliability(laneReqId, &linkInfo, &cb);
1894 EXPECT_EQ(ret, SOFTBUS_OK);
1895
1896 DelLaneResourceByLaneId(laneId, false);
1897 EXPECT_EQ(ret, SOFTBUS_OK);
1898 }
1899
1900 /*
1901 * @tc.name: LANE_DETECT_RELIABILITY_002
1902 * @tc.desc: WLAN LANE DETECT RELIABILITY TEST
1903 * @tc.type: FUNC
1904 * @tc.require:
1905 */
1906 HWTEST_F(LNNLaneMockTest, LANE_DETECT_RELIABILITY_002, TestSize.Level1)
1907 {
1908 NiceMock<LaneDepsInterfaceMock> mock;
1909 int32_t events = 0;
1910 ListenerModule module = LANE;
1911 EXPECT_CALL(mock, StartBaseClient).WillRepeatedly(Return(SOFTBUS_OK));
1912 LaneLinkCb cb = {
1913 .onLaneLinkSuccess = OnLaneLinkSuccess,
1914 .onLaneLinkFail = OnLaneLinkFail,
1915 };
1916
1917 LaneLinkInfo linkInfo;
1918 linkInfo.type = LANE_WLAN_5G;
1919 const LnnLaneManager *laneManager = GetLaneManager();
1920 LaneType laneType = LANE_TYPE_TRANS;
1921 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
1922 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
1923
1924 uint64_t laneId = LANE_ID_BASE;
1925 int32_t ret = AddLaneResourceToPool(&linkInfo, laneId, false);
1926 EXPECT_EQ(ret, SOFTBUS_OK);
1927
1928 ret = LaneDetectOnDataEvent(module, events, FD);
1929 EXPECT_EQ(ret, SOFTBUS_LANE_NOT_FOUND);
1930 EXPECT_CALL(mock, ConnOpenClientSocket).WillRepeatedly(Return(SOFTBUS_OK));
1931 EXPECT_CALL(mock, AddTrigger).WillRepeatedly(Return(SOFTBUS_OK));
1932
1933 ret = LaneDetectReliability(laneReqId, &linkInfo, &cb);
1934 EXPECT_EQ(ret, SOFTBUS_OK);
1935
1936 LaneDetectInfo requestItem = {};
1937 if (GetLaneDetectInfoByWlanFd(SOFTBUS_OK, &requestItem) != SOFTBUS_OK) {
1938 return;
1939 }
1940 bool isSendSuc = true;
1941 ret = NotifyWlanDetectResult(&requestItem, isSendSuc);
1942 EXPECT_EQ(ret, SOFTBUS_OK);
1943
1944 ret = LaneDetectReliability(laneReqId, &linkInfo, &cb);
1945 EXPECT_EQ(ret, SOFTBUS_OK);
1946 ret = LaneDetectOnDataEvent(module, events, SOFTBUS_OK);
1947 EXPECT_EQ(ret, SOFTBUS_OK);
1948 ret = LaneDetectReliability(INVALID_LANE_REQ_ID, &linkInfo, &cb);
1949 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1950
1951 ret = DelLaneResourceByLaneId(laneId, false);
1952 EXPECT_EQ(ret, SOFTBUS_OK);
1953 }
1954
1955 /*
1956 * @tc.name: LANE_DETECT_RELIABILITY_003
1957 * @tc.desc: WLAN LANE DETECT RELIABILITY TEST
1958 * @tc.type: FUNC
1959 * @tc.require:
1960 */
1961 HWTEST_F(LNNLaneMockTest, LANE_DETECT_RELIABILITY_003, TestSize.Level1)
1962 {
1963 const char *ipAddr = "127.0.0.1";
1964 NiceMock<LaneDepsInterfaceMock> mock;
1965 EXPECT_CALL(mock, StartBaseClient).WillRepeatedly(Return(SOFTBUS_OK));
1966 LaneLinkCb cb = {
1967 .onLaneLinkSuccess = OnLaneLinkSuccess,
1968 .onLaneLinkFail = OnLaneLinkFail,
1969 };
1970
1971 LaneLinkInfo linkInfo;
1972 linkInfo.type = LANE_WLAN_5G;
1973 linkInfo.linkInfo.wlan.connInfo.port = PORT_A;
1974 if (strcpy_s(linkInfo.linkInfo.wlan.connInfo.addr, MAX_SOCKET_ADDR_LEN, ipAddr) != EOK) {
1975 return;
1976 }
1977 const LnnLaneManager *laneManager = GetLaneManager();
1978 LaneType laneType = LANE_TYPE_TRANS;
1979 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
1980 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
1981
1982 uint64_t laneId = LANE_ID_BASE;
1983 int32_t ret = AddLaneResourceToPool(&linkInfo, laneId, false);
1984 EXPECT_EQ(ret, SOFTBUS_OK);
1985
1986 EXPECT_CALL(mock, ConnOpenClientSocket)
1987 .WillOnce(Return(SOFTBUS_TCPCONNECTION_SOCKET_ERR))
1988 .WillRepeatedly(Return(SOFTBUS_OK));
1989 EXPECT_CALL(mock, AddTrigger).WillRepeatedly(Return(SOFTBUS_LANE_DETECT_FAIL));
1990
1991 ret = LaneDetectReliability(laneReqId, &linkInfo, &cb);
1992 EXPECT_EQ(ret, SOFTBUS_TCPCONNECTION_SOCKET_ERR);
1993 linkInfo.linkInfo.wlan.connInfo.port = PORT_B;
1994
1995 ret = LaneDetectReliability(laneReqId, &linkInfo, &cb);
1996 EXPECT_EQ(ret, SOFTBUS_LANE_DETECT_FAIL);
1997 ret = DelLaneResourceByLaneId(laneId, false);
1998 EXPECT_EQ(ret, SOFTBUS_OK);
1999 }
2000
2001 /*
2002 * @tc.name: LANE_DETECT_RELIABILITY_004
2003 * @tc.desc: WLAN LANE DETECT RELIABILITY TEST
2004 * @tc.type: FUNC
2005 * @tc.require:
2006 */
2007 HWTEST_F(LNNLaneMockTest, LANE_DETECT_RELIABILITY_004, TestSize.Level1)
2008 {
2009 const char *ipAddr = "127.0.0.1";
2010 LaneLinkCb cb = {
2011 .onLaneLinkSuccess = OnLaneLinkSuccessForDetect,
2012 .onLaneLinkFail = OnLaneLinkFailForDetect,
2013 };
2014
2015 LaneLinkInfo linkInfo;
2016 linkInfo.type = LANE_WLAN_5G;
2017 linkInfo.linkInfo.wlan.connInfo.port = PORT_A;
2018 EXPECT_EQ(strcpy_s(linkInfo.linkInfo.wlan.connInfo.addr, MAX_SOCKET_ADDR_LEN, ipAddr), EOK);
2019 const LnnLaneManager *laneManager = GetLaneManager();
2020 LaneType laneType = LANE_TYPE_TRANS;
2021 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
2022 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
2023
2024 NiceMock<LaneDepsInterfaceMock> mock;
2025 EXPECT_CALL(mock, ConnOpenClientSocket)
2026 .WillOnce(Return(SOFTBUS_TCPCONNECTION_SOCKET_ERR))
2027 .WillRepeatedly(Return(SOFTBUS_OK));
2028 EXPECT_CALL(mock, AddTrigger).WillOnce(Return(SOFTBUS_CONN_FAIL))
2029 .WillRepeatedly(LaneDepsInterfaceMock::ActionOfAddTrigger);
2030 char buf[] = "lanedetect";
2031 EXPECT_CALL(mock, ConnSendSocketData).WillRepeatedly(Return(sizeof(buf)));
2032
2033 int32_t ret = LaneDetectReliability(laneReqId, &linkInfo, &cb);
2034 EXPECT_EQ(ret, SOFTBUS_TCPCONNECTION_SOCKET_ERR);
2035
2036 ret = LaneDetectReliability(laneReqId, &linkInfo, &cb);
2037 EXPECT_EQ(ret, SOFTBUS_CONN_FAIL);
2038
2039 ret = LaneDetectReliability(laneReqId, &linkInfo, &cb);
2040 EXPECT_EQ(ret, SOFTBUS_OK);
2041 }
2042
2043 /*
2044 * @tc.name: LANE_DETECT_RELIABILITY_005
2045 * @tc.desc: WLAN LANE DETECT RELIABILITY, SOFTBUS_SOCKET_EXCEPTION
2046 * @tc.type: FUNC
2047 * @tc.require:
2048 */
2049 HWTEST_F(LNNLaneMockTest, LANE_DETECT_RELIABILITY_005, TestSize.Level1)
2050 {
2051 const char *ipAddr = "127.0.0.1";
2052 LaneLinkCb cb = {
2053 .onLaneLinkSuccess = OnLaneLinkSuccessForDetect,
2054 .onLaneLinkFail = OnLaneLinkFailForDetect,
2055 };
2056
2057 LaneLinkInfo linkInfo;
2058 linkInfo.type = LANE_WLAN_5G;
2059 linkInfo.linkInfo.wlan.connInfo.port = PORT_A;
2060 EXPECT_EQ(strcpy_s(linkInfo.linkInfo.wlan.connInfo.addr, MAX_SOCKET_ADDR_LEN, ipAddr), EOK);
2061 const LnnLaneManager *laneManager = GetLaneManager();
2062 LaneType laneType = LANE_TYPE_TRANS;
2063 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
2064 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
2065 LaneDepsInterfaceMock::socketEvent = SOFTBUS_SOCKET_EXCEPTION;
2066 NiceMock<LaneDepsInterfaceMock> mock;
2067 EXPECT_CALL(mock, ConnOpenClientSocket).WillRepeatedly(Return(SOFTBUS_OK));
2068 EXPECT_CALL(mock, AddTrigger).WillRepeatedly(LaneDepsInterfaceMock::ActionOfAddTrigger);
2069 char buf[] = "lanedetect";
2070 EXPECT_CALL(mock, ConnSendSocketData).WillRepeatedly(Return(sizeof(buf)));
2071
2072 int32_t ret = LaneDetectReliability(laneReqId, &linkInfo, &cb);
2073 EXPECT_EQ(ret, SOFTBUS_OK);
2074 }
2075
2076 /*
2077 * @tc.name: LANE_DETECT_RELIABILITY_006
2078 * @tc.desc: WLAN LANE DETECT RELIABILITY TIMEOUT
2079 * @tc.type: FUNC
2080 * @tc.require:
2081 */
2082 HWTEST_F(LNNLaneMockTest, LANE_DETECT_RELIABILITY_006, TestSize.Level1)
2083 {
2084 const char *ipAddr = "127.0.0.1";
2085 LaneLinkCb cb = {
2086 .onLaneLinkSuccess = OnLaneLinkSuccessForDetect,
2087 .onLaneLinkFail = OnLaneLinkFailForDetect,
2088 };
2089
2090 LaneLinkInfo linkInfo;
2091 linkInfo.type = LANE_WLAN_5G;
2092 linkInfo.linkInfo.wlan.connInfo.port = PORT_A;
2093 EXPECT_EQ(strcpy_s(linkInfo.linkInfo.wlan.connInfo.addr, MAX_SOCKET_ADDR_LEN, ipAddr), EOK);
2094 const LnnLaneManager *laneManager = GetLaneManager();
2095 LaneType laneType = LANE_TYPE_TRANS;
2096 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
2097 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
2098
2099 NiceMock<LaneDepsInterfaceMock> mock;
2100 EXPECT_CALL(mock, ConnOpenClientSocket).WillRepeatedly(Return(SOFTBUS_OK));
2101 EXPECT_CALL(mock, AddTrigger).WillRepeatedly(Return(SOFTBUS_OK));
2102 char buf[] = "lanedetect";
2103 EXPECT_CALL(mock, ConnSendSocketData).WillRepeatedly(Return(sizeof(buf)));
2104 SetIsNeedCondWait();
2105 int32_t ret = LaneDetectReliability(laneReqId, &linkInfo, &cb);
2106 EXPECT_EQ(ret, SOFTBUS_OK);
2107 CondWait();
2108 }
2109
2110 /*
2111 * @tc.name: LANE_INIT_RELIABLITY_001
2112 * @tc.desc: LANE INIT RELIABLITY TEST
2113 * @tc.type: FUNC
2114 * @tc.require:
2115 */
2116 HWTEST_F(LNNLaneMockTest, LANE_INIT_RELIABLITY_001, TestSize.Level1)
2117 {
2118 NiceMock<LaneDepsInterfaceMock> mock;
2119 EXPECT_CALL(mock, StartBaseClient).WillRepeatedly(Return(SOFTBUS_OK));
2120 int32_t ret = InitLaneReliability();
2121 EXPECT_EQ(ret, SOFTBUS_OK);
2122 }
2123
2124 /*
2125 * @tc.name: LNN_AUTH_ALLOC_TEST_001
2126 * @tc.desc: AuthAlloc
2127 * @tc.type: FUNC
2128 * @tc.require:
2129 */
2130 HWTEST_F(LNNLaneMockTest, LNN_AUTH_ALLOC_TEST_001, TestSize.Level1)
2131 {
2132 const LnnLaneManager *laneManager = GetLaneManager();
2133 LaneType laneType = LANE_TYPE_CTRL;
2134 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
2135 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
2136
2137 NiceMock<LaneDepsInterfaceMock> mock;
2138 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
2139 EXPECT_CALL(mock, LnnGetLocalNumInfo)
2140 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(16), Return(SOFTBUS_OK)));
2141 EXPECT_CALL(mock, LnnGetRemoteNumInfo)
2142 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(16), Return(SOFTBUS_OK)));
2143 EXPECT_CALL(mock, LnnGetLocalNumU32Info)
2144 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(16), Return(SOFTBUS_OK)));
2145 EXPECT_CALL(mock, LnnGetRemoteNumU32Info)
2146 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(16), Return(SOFTBUS_OK)));
2147
2148 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
2149 wifiMock.SetDefaultResult();
2150
2151 LaneAllocInfo allocInfo = {};
2152 allocInfo.type = laneType;
2153 (void)strncpy_s(allocInfo.networkId, NETWORK_ID_BUF_LEN,
2154 NODE_NETWORK_ID, strlen(NODE_NETWORK_ID));
2155 allocInfo.transType = LANE_T_BYTE;
2156 allocInfo.qosRequire.minBW = 0;
2157 allocInfo.qosRequire.maxLaneLatency = 0;
2158 allocInfo.qosRequire.minLaneLatency = 0;
2159
2160 int32_t ret = laneManager->lnnAllocLane(laneReqId, nullptr, &g_listener);
2161 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2162
2163 ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, nullptr);
2164 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2165
2166 ret = laneManager->lnnAllocLane(INVALID_LANE_REQ_ID, &allocInfo, &g_listener);
2167 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2168 }
2169
2170 /*
2171 * @tc.name: LNN_LANE_03
2172 * @tc.desc: SelectLaneRule
2173 * @tc.type: FUNC
2174 * @tc.require:
2175 */
2176 HWTEST_F(LNNLaneMockTest, LNN_LANE_03, TestSize.Level1)
2177 {
2178 uint32_t laneReqId = 0;
2179 LaneRequestOption request;
2180 ILaneListener listener;
2181 ILaneIdStateListener laneListener;
2182
2183 RegisterLaneIdListener(nullptr);
2184 laneListener.OnLaneIdEnabled = nullptr;
2185 laneListener.OnLaneIdDisabled = nullptr;
2186 RegisterLaneIdListener(&laneListener);
2187 UnregisterLaneIdListener(nullptr);
2188 FreeLaneReqId(laneReqId);
2189 laneReqId = 0xfffffff;
2190 FreeLaneReqId(laneReqId);
2191 request.type = LANE_TYPE_BUTT;
2192 int32_t ret = LnnRequestLane(0, &request, &listener);
2193 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2194
2195 request.type = (LaneType)-1;
2196 ret = LnnRequestLane(0, &request, &listener);
2197 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2198 }
2199
2200 /*
2201 * @tc.name: LNN_LANE_04
2202 * @tc.desc: SelectLaneRule
2203 * @tc.type: FUNC
2204 * @tc.require:
2205 */
2206 HWTEST_F(LNNLaneMockTest, LNN_LANE_04, TestSize.Level1)
2207 {
2208 RawLaneAllocInfo allocInfo;
2209 LaneAllocListener listener;
2210
2211 const LnnLaneManager *laneManager = GetLaneManager();
2212 LaneType laneType = LANE_TYPE_TRANS;
2213 uint32_t laneHandle = laneManager->lnnGetLaneHandle(laneType);
2214 EXPECT_TRUE(laneHandle != INVALID_LANE_REQ_ID);
2215
2216 int32_t ret = laneManager->lnnAllocRawLane(laneHandle, nullptr, &listener);
2217 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2218 ret = laneManager->lnnAllocRawLane(laneHandle, &allocInfo, nullptr);
2219 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2220 ret = laneManager->lnnAllocRawLane(laneHandle, nullptr, nullptr);
2221 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2222
2223 allocInfo.type = LANE_TYPE_BUTT;
2224 ret = laneManager->lnnAllocRawLane(laneHandle, &allocInfo, &listener);
2225 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2226
2227 allocInfo.type = (LaneType)-1;
2228 ret = laneManager->lnnAllocRawLane(laneHandle, &allocInfo, &listener);
2229 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2230 }
2231
2232 /*
2233 * @tc.name: LNN_LANE_05
2234 * @tc.desc: SelectLaneRule
2235 * @tc.type: FUNC
2236 * @tc.require:
2237 */
2238 HWTEST_F(LNNLaneMockTest, LNN_LANE_05, TestSize.Level1)
2239 {
2240 NiceMock<LaneDepsInterfaceMock> laneDepMock;
2241 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
2242 const LnnLaneManager *laneManager = GetLaneManager();
2243 LaneType laneType = LANE_TYPE_TRANS;
2244 uint32_t laneHandle = laneManager->lnnGetLaneHandle(laneType);
2245 EXPECT_TRUE(laneHandle != INVALID_LANE_REQ_ID);
2246
2247 EXPECT_CALL(wifiMock, LnnConnectP2p).WillRepeatedly(Return(SOFTBUS_OK));
2248 RawLaneAllocInfo allocInfo;
2249 allocInfo.type = LANE_TYPE_HDLC;
2250 LaneAllocListener listener;
2251 int32_t ret = laneManager->lnnAllocRawLane(laneHandle, &allocInfo, &listener);
2252 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2253
2254 ret = laneManager->lnnFreeLane(laneHandle);
2255 EXPECT_EQ(ret, SOFTBUS_LANE_NOT_FOUND);
2256 }
2257
2258 /*
2259 * @tc.name: LNN_LANE_06
2260 * @tc.desc: SelectLaneRule
2261 * @tc.type: FUNC
2262 * @tc.require:
2263 */
2264 HWTEST_F(LNNLaneMockTest, LNN_LANE_06, TestSize.Level1)
2265 {
2266 NiceMock<LaneDepsInterfaceMock> laneDepMock;
2267 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
2268 const LnnLaneManager *laneManager = GetLaneManager();
2269 LaneType laneType = LANE_TYPE_TRANS;
2270 uint32_t laneHandle = laneManager->lnnGetLaneHandle(laneType);
2271 EXPECT_TRUE(laneHandle != INVALID_LANE_REQ_ID);
2272
2273 EXPECT_CALL(wifiMock, LnnConnectP2p).WillRepeatedly(Return(SOFTBUS_OK));
2274 RawLaneAllocInfo allocInfo;
2275 allocInfo.type = LANE_TYPE_TRANS;
2276 LaneAllocListener listener = {
2277 .onLaneFreeSuccess = OnLaneFreeSuccess,
2278 .onLaneFreeFail = OnLaneFreeFail,
2279 };
2280 SetIsNeedCondWait();
2281 int32_t ret = laneManager->lnnAllocRawLane(laneHandle, &allocInfo, &listener);
2282 EXPECT_EQ(ret, SOFTBUS_OK);
2283 CondWait();
2284 SetIsNeedCondWait();
2285 ret = laneManager->lnnFreeLane(laneHandle);
2286 EXPECT_EQ(ret, SOFTBUS_OK);
2287 CondWait();
2288 }
2289
2290 /*
2291 * @tc.name: LNN_LANE_07
2292 * @tc.desc: SelectLaneRule
2293 * @tc.type: FUNC
2294 * @tc.require:
2295 */
2296 HWTEST_F(LNNLaneMockTest, LNN_LANE_07, TestSize.Level1)
2297 {
2298 LaneAllocInfoExt allocInfo;
2299 LaneAllocListener listener;
2300 NiceMock<LaneDepsInterfaceMock> laneDepMock;
2301
2302 const LnnLaneManager *laneManager = GetLaneManager();
2303 LaneType laneType = LANE_TYPE_TRANS;
2304 uint32_t laneHandle = laneManager->lnnGetLaneHandle(laneType);
2305 EXPECT_TRUE(laneHandle != INVALID_LANE_REQ_ID);
2306
2307 int32_t ret = laneManager->lnnAllocTargetLane(laneHandle, &allocInfo, nullptr);
2308 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2309 ret = laneManager->lnnAllocTargetLane(laneHandle, nullptr, &listener);
2310 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2311 ret = laneManager->lnnAllocTargetLane(laneHandle, nullptr, nullptr);
2312 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2313 ret = laneManager->lnnAllocTargetLane(INVALID_LANE_REQ_ID, nullptr, nullptr);
2314 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2315 ret = laneManager->lnnAllocTargetLane(INVALID_LANE_REQ_ID, nullptr, &listener);
2316 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2317 ret = laneManager->lnnAllocTargetLane(INVALID_LANE_REQ_ID, &allocInfo, &listener);
2318 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2319 allocInfo.type = LANE_TYPE_BUTT;
2320 ret = laneManager->lnnAllocTargetLane(laneHandle, &allocInfo, &listener);
2321 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2322 allocInfo.type = LANE_TYPE_TRANS;
2323 allocInfo.linkList.linkTypeNum = LANE_LINK_TYPE_BUTT;
2324 ret = laneManager->lnnAllocTargetLane(laneHandle, &allocInfo, &listener);
2325 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2326 }
2327
2328 /*
2329 * @tc.name: LNN_LANE_08
2330 * @tc.desc: SelectLaneRule
2331 * @tc.type: FUNC
2332 * @tc.require:
2333 */
2334 HWTEST_F(LNNLaneMockTest, LNN_LANE_08, TestSize.Level1)
2335 {
2336 LaneAllocInfoExt allocInfo;
2337 NiceMock<LaneDepsInterfaceMock> laneDepMock;
2338 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
2339 const LnnLaneManager *laneManager = GetLaneManager();
2340 LaneType laneType = LANE_TYPE_TRANS;
2341 uint32_t laneHandle = laneManager->lnnGetLaneHandle(laneType);
2342 EXPECT_TRUE(laneHandle != INVALID_LANE_REQ_ID);
2343
2344 EXPECT_CALL(laneDepMock, DeleteNetworkResourceByLaneId).WillRepeatedly(Return());
2345 EXPECT_CALL(laneDepMock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
2346 laneDepMock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
2347 laneDepMock.SetDefaultResultForAlloc(1 << BIT_WIFI_P2P, 1 << BIT_WIFI_P2P, 8, 8);
2348 wifiMock.SetDefaultResult();
2349 EXPECT_CALL(wifiMock, LnnConnectP2p(NotNull(), laneHandle, NotNull()))
2350 .WillRepeatedly(LnnWifiAdpterInterfaceMock::ActionOfLnnConnectP2p);
2351
2352 allocInfo.linkList.linkTypeNum = LANE_LINK_TYPE_BUTT - 1;
2353 allocInfo.type = LANE_TYPE_TRANS;
2354 SetIsNeedCondWait();
2355 int32_t ret = laneManager->lnnAllocTargetLane(laneHandle, &allocInfo, &g_listenerCbForBr2);
2356 EXPECT_EQ(ret, SOFTBUS_OK);
2357 CondWait();
2358 SetIsNeedCondWait();
2359 ret = laneManager->lnnFreeLane(laneHandle);
2360 EXPECT_EQ(ret, SOFTBUS_OK);
2361 CondWait();
2362 }
2363
2364 /*
2365 * @tc.name: LNN_LANE_12
2366 * @tc.desc: SelectLaneRule
2367 * @tc.type: FUNC
2368 * @tc.require:
2369 */
2370 HWTEST_F(LNNLaneMockTest, LNN_LANE_12, TestSize.Level1)
2371 {
2372 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
2373 const LnnLaneManager *laneManager = GetLaneManager();
2374 LaneType laneType = LANE_TYPE_TRANS;
2375 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
2376 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
2377
2378 wifiMock.SetDefaultResult();
2379 EXPECT_CALL(wifiMock, LnnConnectP2p(NotNull(), laneReqId, NotNull()))
2380 .WillRepeatedly(LnnWifiAdpterInterfaceMock::ActionOfOnConnectP2pFail);
2381 NiceMock<LaneDepsInterfaceMock> mock;
2382 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
2383 mock.SetDefaultResultForAlloc(63, 63, 0, 0);
2384 EXPECT_CALL(mock, ConnOpenClientSocket).WillRepeatedly(Return(SOFTBUS_CONN_FAIL));
2385 EXPECT_CALL(mock, DeleteNetworkResourceByLaneId).WillRepeatedly(Return());
2386 LaneAllocInfo allocInfo = {};
2387 CreateAllocInfoForAllocTest(LANE_T_MSG, DEFAULT_QOSINFO_MIN_BW + HIGH_BW, DEFAULT_QOSINFO_MAX_LATENCY,
2388 DEFAULT_QOSINFO_MIN_LATENCY, &allocInfo);
2389 SetIsNeedCondWait();
2390 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listener);
2391 EXPECT_EQ(ret, SOFTBUS_OK);
2392 CondWait();
2393 }
2394
2395 /*
2396 * @tc.name: LNN_LANE_13
2397 * @tc.desc: SelectLaneRule
2398 * @tc.type: FUNC
2399 * @tc.require:
2400 */
2401 HWTEST_F(LNNLaneMockTest, LNN_LANE_13, TestSize.Level1)
2402 {
2403 LaneType laneType = LANE_TYPE_TRANS;
2404 uint32_t laneReqId = ApplyLaneReqId(laneType);
2405 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
2406 NiceMock<LaneDepsInterfaceMock> mock;
2407 EXPECT_CALL(mock, LnnGetLocalNumInfo).WillRepeatedly(DoAll(SetArgPointee<1>(NET_CAP), Return(SOFTBUS_OK)));
2408 EXPECT_CALL(mock, LnnGetRemoteNumInfo).WillRepeatedly(DoAll(SetArgPointee<2>(NET_CAP), Return(SOFTBUS_OK)));
2409 EXPECT_CALL(mock, LnnGetOnlineStateById).WillRepeatedly(Return(true));
2410 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
2411 EXPECT_CALL(wifiMock, SoftBusGetLinkBand).WillRepeatedly(Return(BAND_5G));
2412
2413 LaneRequestOption requestOption = {};
2414 requestOption.type = laneType;
2415 EXPECT_EQ(strncpy_s(requestOption.requestInfo.trans.networkId, NETWORK_ID_BUF_LEN,
2416 NODE_NETWORK_ID, strlen(NODE_NETWORK_ID)), EOK);
2417 requestOption.requestInfo.trans.transType = LANE_T_COMMON_VIDEO;
2418 requestOption.requestInfo.trans.expectedBw = 0;
2419 requestOption.requestInfo.trans.pid = 0;
2420 requestOption.requestInfo.trans.expectedLink.linkTypeNum = 1;
2421 requestOption.requestInfo.trans.expectedLink.linkType[0] = LANE_WLAN_5G;
2422
2423 int32_t ret = LnnRequestLane(laneReqId, &requestOption, &g_listener2);
2424 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_OFF);
2425 ret = LnnFreeLane(laneReqId);
2426 EXPECT_EQ(ret, SOFTBUS_LANE_NOT_FOUND);
2427 }
2428 } // namespace OHOS
2429