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_info.h"
24 #include "lnn_lane_link_proc.h"
25 #include "lnn_lane_select.h"
26 #include "lnn_local_net_ledger.h"
27 #include "message_handler.h"
28 #include "softbus_adapter_mem.h"
29 #include "softbus_adapter_timer.h"
30 #include "softbus_errcode.h"
31 #include "softbus_utils.h"
32
33 namespace OHOS {
34 using namespace testing::ext;
35 constexpr char NODE_NETWORK_ID[] = "111122223333abcdef";
36 constexpr char NODE_UDID[] = "123456ABCDEF";
37 constexpr char NODE_BT_MAC[] = "b1:ab:cd:ef:aa:d7";
38 constexpr uint32_t REMOTE_SESSION_PORT = 6060;
39 constexpr uint32_t REMOTE_AUTH_PORT = 7070;
40 constexpr uint32_t REMOTE_PROXY_PORT = 8080;
41 constexpr char REMOTE_WLAN_IP[] = "10.146.181.134";
42 constexpr char LOCAL_NETWORK_ID[] = "444455556666abcdef";
43 constexpr uint32_t FILE_DEFAULT_LINK_NUM = 4;
44 constexpr uint32_t LANE_PREFERRED_LINK_NUM = 2;
45 constexpr uint32_t LANE_LINK_NUM = 2;
46
47 static NodeInfo g_nodeInfo;
48 constexpr int32_t DEFAULT_PID = 0;
49
50 static void ConstructRemoteNode(void);
51 static void ConstructLocalInfo(void);
52
53 class LaneTest : public testing::Test {
54 public:
55 static void SetUpTestCase();
56 static void TearDownTestCase();
57 void SetUp();
58 void TearDown();
59 };
60
SetUpTestCase()61 void LaneTest::SetUpTestCase()
62 {
63 int32_t ret = LooperInit();
64 EXPECT_TRUE(ret == SOFTBUS_OK);
65 ret = LnnInitDistributedLedger();
66 EXPECT_TRUE(ret == SOFTBUS_OK);
67 ret = LnnInitLocalLedger();
68 EXPECT_TRUE(ret == SOFTBUS_OK);
69 ret = InitLane();
70 EXPECT_TRUE(ret == SOFTBUS_OK);
71 ConstructRemoteNode();
72 ConstructLocalInfo();
73 GTEST_LOG_(INFO) << "LaneTest start";
74 }
75
TearDownTestCase()76 void LaneTest::TearDownTestCase()
77 {
78 DeinitLane();
79 LnnDeinitLocalLedger();
80 LnnDeinitDistributedLedger();
81 LooperDeinit();
82 (void)memset_s(&g_nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
83 GTEST_LOG_(INFO) << "LaneTest end";
84 }
85
SetUp()86 void LaneTest::SetUp()
87 {
88 }
89
TearDown()90 void LaneTest::TearDown()
91 {
92 }
93
ConstructRemoteNode(void)94 static void ConstructRemoteNode(void)
95 {
96 (void)memset_s(&g_nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
97 uint32_t cap = 0;
98 LnnSetNetCapability(&cap, BIT_BR);
99 LnnSetNetCapability(&cap, BIT_WIFI_P2P);
100 LnnSetNetCapability(&cap, BIT_WIFI_24G);
101 LnnSetNetCapability(&cap, BIT_WIFI_5G);
102 g_nodeInfo.netCapacity = cap;
103 int ret = strncpy_s(g_nodeInfo.networkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID, strlen(NODE_NETWORK_ID));
104 EXPECT_TRUE(ret == EOK);
105 ret = LnnSetDeviceUdid(&g_nodeInfo, NODE_UDID);
106 EXPECT_TRUE(ret == SOFTBUS_OK);
107 ret = LnnSetDiscoveryType(&g_nodeInfo, DISCOVERY_TYPE_WIFI);
108 EXPECT_TRUE(ret == SOFTBUS_OK);
109 ret = LnnSetProxyPort(&g_nodeInfo, REMOTE_PROXY_PORT);
110 EXPECT_TRUE(ret == SOFTBUS_OK);
111 ret = LnnSetSessionPort(&g_nodeInfo, REMOTE_SESSION_PORT);
112 EXPECT_TRUE(ret == SOFTBUS_OK);
113 LnnSetWiFiIp(&g_nodeInfo, REMOTE_WLAN_IP);
114 ret = LnnSetAuthPort(&g_nodeInfo, REMOTE_AUTH_PORT);
115 EXPECT_TRUE(ret == SOFTBUS_OK);
116 LnnSetBtMac(&g_nodeInfo, NODE_BT_MAC);
117 (void)LnnAddOnlineNode(&g_nodeInfo);
118 }
119
ConstructLocalInfo(void)120 static void ConstructLocalInfo(void)
121 {
122 int32_t ret = LnnSetLocalStrInfo(STRING_KEY_NETWORKID, LOCAL_NETWORK_ID);
123 EXPECT_TRUE(ret == SOFTBUS_OK);
124 ret = LnnSetLocalNumInfo(NUM_KEY_NET_CAP, (1 << BIT_BR) |
125 (1 << BIT_WIFI_24G) | (1 << BIT_WIFI_5G) | (1 << BIT_WIFI_P2P));
126 EXPECT_TRUE(ret == SOFTBUS_OK);
127 }
128
NotifyWlanLinkSuccess(uint32_t reqId,const LaneLinkInfo * linkInfo)129 static void NotifyWlanLinkSuccess(uint32_t reqId, const LaneLinkInfo *linkInfo)
130 {
131 EXPECT_TRUE((linkInfo->type == LANE_WLAN_2P4G) || (linkInfo->type == LANE_WLAN_5G));
132 EXPECT_EQ(linkInfo->linkInfo.wlan.connInfo.port, REMOTE_SESSION_PORT);
133 EXPECT_STREQ(REMOTE_WLAN_IP, linkInfo->linkInfo.wlan.connInfo.addr);
134 printf("WLAN: linkSuccess, reqId:0x%x\n", reqId);
135 }
136
NotifyWlanLinkFail(uint32_t reqId,int32_t reason)137 static void NotifyWlanLinkFail(uint32_t reqId, int32_t reason)
138 {
139 printf("WLAN: reqId:0x%x, fail reason:%d\n", reqId, reason);
140 }
141
NotifyWlanLinkException(uint32_t reqId,int32_t reason)142 static void NotifyWlanLinkException(uint32_t reqId, int32_t reason)
143 {
144 printf("WLAN: reqId:0x%x, exception reason:%d\n", reqId, reason);
145 }
146
NotifyBrLinkSuccess(uint32_t reqId,const LaneLinkInfo * linkInfo)147 static void NotifyBrLinkSuccess(uint32_t reqId, 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)154 static void NotifyBrLinkFail(uint32_t reqId, int32_t reason)
155 {
156 printf("BR: reqId:0x%x, reason:%d\n", reqId, reason);
157 }
158
NotifyBrLinkException(uint32_t reqId,int32_t reason)159 static void NotifyBrLinkException(uint32_t reqId, int32_t reason)
160 {
161 printf("BR: reqId:0x%x, reason:%d\n", reqId, reason);
162 }
163
GetLinkType(LaneLinkType type)164 static const char *GetLinkType(LaneLinkType type)
165 {
166 switch (type) {
167 case LANE_BR:
168 return "BR";
169 case LANE_WLAN_2P4G:
170 return "Wlan_2.4G";
171 case LANE_WLAN_5G:
172 return "Wlan_5G";
173 case LANE_P2P:
174 return "P2P";
175 default:
176 return "Unknown-Link";
177 }
178 }
179
OnLaneRequestSuccess(uint32_t laneId,const LaneConnInfo * info)180 static void OnLaneRequestSuccess(uint32_t laneId, const LaneConnInfo *info)
181 {
182 printf("LaneRequestSucc: laneId:0x%x, linkType:%s\n", laneId, GetLinkType(info->type));
183 int32_t ret = LnnFreeLane(laneId);
184 EXPECT_TRUE(ret == SOFTBUS_OK);
185 }
186
OnLaneRequestFail(uint32_t laneId,LaneRequestFailReason reason)187 static void OnLaneRequestFail(uint32_t laneId, LaneRequestFailReason reason)
188 {
189 printf("LaneRequestFail: laneId:0x%x, reason:%d\n", laneId, reason);
190 int32_t ret = LnnFreeLane(laneId);
191 EXPECT_TRUE(ret == SOFTBUS_OK);
192 }
193
OnLaneStateChange(uint32_t laneId,LaneState state)194 static void OnLaneStateChange(uint32_t laneId, LaneState state)
195 {
196 printf("LaneStateChange: laneId:0x%x, state:%d\n", laneId, state);
197 int32_t ret = LnnFreeLane(laneId);
198 EXPECT_TRUE(ret == SOFTBUS_OK);
199 }
200
201 /*
202 * @tc.name: LANE_ID_APPLY_Test_001
203 * @tc.desc: apply laneId test
204 * @tc.type: FUNC
205 * @tc.require: I5FBFG
206 */
207 HWTEST_F(LaneTest, LANE_ID_APPLY_Test_001, TestSize.Level1)
208 {
209 LaneType laneType = LANE_TYPE_TRANS;
210 uint32_t laneId = ApplyLaneId(laneType);
211 EXPECT_TRUE(laneId != INVALID_LANE_ID);
212 int32_t ret = LnnFreeLane(laneId);
213 EXPECT_TRUE(ret == SOFTBUS_OK);
214 }
215
216 /*
217 * @tc.name: LANE_ID_APPLY_Test_002
218 * @tc.desc: apply laneId test
219 * @tc.type: FUNC
220 * @tc.require: I5FBFG
221 */
222 HWTEST_F(LaneTest, LANE_ID_APPLY_Test_002, TestSize.Level1)
223 {
224 LaneType laneType = LANE_TYPE_TRANS;
225 uint32_t laneId;
226 uint32_t *laneIdList = (uint32_t *)SoftBusCalloc(sizeof(uint32_t) * MAX_LANE_ID_NUM);
227 if (laneIdList == nullptr) {
228 return;
229 }
230 uint32_t i;
231 for (i = 0; i < MAX_LANE_ID_NUM; i++) {
232 laneId = ApplyLaneId(laneType);
233 EXPECT_TRUE(laneId != INVALID_LANE_ID);
234 laneIdList[i] = laneId;
235 }
236 laneId = ApplyLaneId(laneType);
237 EXPECT_TRUE(laneId == INVALID_LANE_ID);
238 for (i = 0; i < MAX_LANE_ID_NUM; i++) {
239 EXPECT_EQ(LnnFreeLane(laneIdList[i]), SOFTBUS_OK);
240 }
241 SoftBusFree(laneIdList);
242 }
243
244 /*
245 * @tc.name: LANE_SELECT_Test_001
246 * @tc.desc: lane select fileTransLane by LNN
247 * @tc.type: FUNC
248 * @tc.require: I5FBFG
249 */
250 HWTEST_F(LaneTest, LANE_SELECT_Test_001, TestSize.Level1)
251 {
252 LaneLinkType *recommendList = nullptr;
253 uint32_t listNum = 0;
254 LaneSelectParam selectParam;
255 (void)memset_s(&selectParam, sizeof(LaneSelectParam), 0, sizeof(LaneSelectParam));
256 selectParam.transType = LANE_T_FILE;
257 selectParam.expectedBw = 0;
258 int32_t ret = SelectLane(NODE_NETWORK_ID, &selectParam, &recommendList, &listNum);
259 EXPECT_TRUE(ret == SOFTBUS_OK);
260 EXPECT_TRUE(recommendList != nullptr);
261 EXPECT_TRUE(listNum == FILE_DEFAULT_LINK_NUM);
262 LaneLinkType fileLinkList[FILE_DEFAULT_LINK_NUM] = {LANE_WLAN_5G, LANE_P2P, LANE_WLAN_2P4G, LANE_BR};
263 for (uint32_t i = 0; i < listNum; i++) {
264 EXPECT_TRUE(fileLinkList[i] == recommendList[i]);
265 }
266 SoftBusFree(recommendList);
267 }
268
269 /*
270 * @tc.name: LANE_SELECT_Test_002
271 * @tc.desc: lane select by preferredLinkList
272 * @tc.type: FUNC
273 * @tc.require: I5FBFG
274 */
275 HWTEST_F(LaneTest, LANE_SELECT_Test_002, TestSize.Level1)
276 {
277 LaneLinkType *recommendList = nullptr;
278 uint32_t listNum = 0;
279 LaneSelectParam selectParam;
280 (void)memset_s(&selectParam, sizeof(LaneSelectParam), 0, sizeof(LaneSelectParam));
281 selectParam.transType = LANE_T_BYTE;
282 selectParam.expectedBw = 0;
283 selectParam.list.linkTypeNum = LANE_PREFERRED_LINK_NUM;
284 selectParam.list.linkType[0] = LANE_WLAN_5G;
285 selectParam.list.linkType[1] = LANE_BR;
286 int32_t ret = SelectLane(NODE_NETWORK_ID, &selectParam, &recommendList, &listNum);
287 EXPECT_TRUE(ret == SOFTBUS_OK);
288 EXPECT_TRUE(recommendList != nullptr);
289 EXPECT_TRUE(listNum == LANE_PREFERRED_LINK_NUM);
290 for (uint32_t i = 0; i < listNum; i++) {
291 EXPECT_TRUE(selectParam.list.linkType[i] == recommendList[i]);
292 }
293 SoftBusFree(recommendList);
294 }
295
296 /*
297 * @tc.name: LANE_LINK_Test_001
298 * @tc.desc: LaneLink of wlan5G
299 * @tc.type: FUNC
300 * @tc.require: I5FBFG
301 */
302 HWTEST_F(LaneTest, LANE_LINK_Test_001, TestSize.Level1)
303 {
304 LinkRequest reqInfo;
305 (void)memset_s(&reqInfo, sizeof(LinkRequest), 0, sizeof(LinkRequest));
306 int32_t ret = memcpy_s(reqInfo.peerNetworkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID, strlen(NODE_NETWORK_ID));
307 EXPECT_TRUE(ret == EOK);
308 reqInfo.linkType = LANE_WLAN_2P4G;
309 reqInfo.transType = LANE_T_BYTE;
310 reqInfo.pid = DEFAULT_PID;
311 LaneLinkCb linkCb = {
312 .OnLaneLinkSuccess = NotifyWlanLinkSuccess,
313 .OnLaneLinkFail = NotifyWlanLinkFail,
314 .OnLaneLinkException = NotifyWlanLinkException,
315 };
316 uint32_t requestId = 0x5A5A;
317 ret = BuildLink(&reqInfo, requestId, &linkCb);
318 EXPECT_TRUE(ret == SOFTBUS_OK);
319 }
320
321 /*
322 * @tc.name: LANE_LINK_Test_002
323 * @tc.desc: LaneLink of BR
324 * @tc.type: FUNC
325 * @tc.require: I5FBFG
326 */
327 HWTEST_F(LaneTest, LANE_LINK_Test_002, TestSize.Level1)
328 {
329 LinkRequest reqInfo;
330 (void)memset_s(&reqInfo, sizeof(LinkRequest), 0, sizeof(LinkRequest));
331 int32_t ret = memcpy_s(reqInfo.peerNetworkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID, strlen(NODE_NETWORK_ID));
332 EXPECT_TRUE(ret == EOK);
333 reqInfo.linkType = LANE_BR;
334 reqInfo.transType = LANE_T_BYTE;
335 reqInfo.pid = DEFAULT_PID;
336 LaneLinkCb linkCb = {
337 .OnLaneLinkSuccess = NotifyBrLinkSuccess,
338 .OnLaneLinkFail = NotifyBrLinkFail,
339 .OnLaneLinkException = NotifyBrLinkException,
340 };
341 uint32_t requestId = 0x5A5A;
342 ret = BuildLink(&reqInfo, requestId, &linkCb);
343 EXPECT_TRUE(ret == SOFTBUS_OK);
344 }
345
346 /*
347 * @tc.name: TRANS_LANE_ALLOC_Test_001
348 * @tc.desc: TransLaneRequest test
349 * @tc.type: FUNC
350 * @tc.require: I5FBFG
351 */
352 HWTEST_F(LaneTest, TRANS_LANE_ALLOC_Test_001, TestSize.Level1)
353 {
354 uint32_t laneId = ApplyLaneId(LANE_TYPE_TRANS);
355 EXPECT_TRUE(laneId != INVALID_LANE_ID);
356 LaneRequestOption request;
357 (void)memset_s(&request, sizeof(LaneRequestOption), 0, sizeof(LaneRequestOption));
358 request.type = LANE_TYPE_TRANS;
359 TransOption *trans = &request.requestInfo.trans;
360 int32_t ret = memcpy_s(trans->networkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID, sizeof(NODE_NETWORK_ID));
361 EXPECT_TRUE(ret == EOK);
362 trans->transType = LANE_T_RAW_STREAM;
363 trans->pid = DEFAULT_PID;
364 trans->expectedLink.linkTypeNum = LANE_LINK_NUM;
365 trans->expectedLink.linkType[0] = LANE_P2P;
366 trans->expectedLink.linkType[1] = LANE_WLAN_5G;
367 ILaneListener listener = {
368 .OnLaneRequestSuccess = OnLaneRequestSuccess,
369 .OnLaneRequestFail = OnLaneRequestFail,
370 .OnLaneStateChange = OnLaneStateChange,
371 };
372 ret = LnnRequestLane(laneId, &request, &listener);
373 EXPECT_TRUE(ret == SOFTBUS_OK);
374 SoftBusSleepMs(5);
375 }
376 } // namespace OHOS
377