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