1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17 #include <securec.h>
18
19 #include "bus_center_info_key.h"
20 #include "bus_center_manager.h"
21 #include "lnn_distributed_net_ledger.h"
22 #include "lnn_lane.h"
23 #include "lnn_lane_link.h"
24 #include "lnn_lane_reliability.h"
25 #include "lnn_lane_select.h"
26 #include "lnn_local_net_ledger.h"
27 #include "message_handler.h"
28 #include "softbus_adapter_mem.h"
29 #include "softbus_adapter_timer.h"
30 #include "softbus_error_code.h"
31 #include "softbus_utils.h"
32
33 namespace OHOS {
34 using namespace testing::ext;
35 using namespace testing;
36 constexpr char NODE_NETWORK_ID[] = "111122223333abcdef";
37 constexpr char NODE_UDID[] = "123456ABCDEF";
38 constexpr char NODE_BT_MAC[] = "b1:ab:cd:ef:aa:d7";
39 constexpr uint32_t REMOTE_SESSION_PORT = 6060;
40 constexpr uint32_t REMOTE_AUTH_PORT = 7070;
41 constexpr uint32_t REMOTE_PROXY_PORT = 8080;
42 constexpr char REMOTE_WLAN_IP[] = "10.146.181.134";
43 constexpr char LOCAL_NETWORK_ID[] = "444455556666abcdef";
44 constexpr uint32_t LANE_REQID_TYPE_SHIFT = 28;
45 constexpr uint64_t LANE_ID = 123456;
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 = LnnInitDistributedLedger();
64 EXPECT_TRUE(ret == SOFTBUS_OK);
65 ret = LnnInitLocalLedger();
66 EXPECT_TRUE(ret == SOFTBUS_OK);
67 ret = LnnInitLnnLooper();
68 EXPECT_TRUE(ret == SOFTBUS_OK);
69 ret = LooperInit();
70 EXPECT_TRUE(ret == SOFTBUS_OK);
71 ret = InitLane();
72 EXPECT_TRUE(ret == SOFTBUS_OK);
73 ConstructRemoteNode();
74 ConstructLocalInfo();
75 GTEST_LOG_(INFO) << "LaneTest start";
76 }
77
TearDownTestCase()78 void LaneTest::TearDownTestCase()
79 {
80 DeinitLane();
81 LooperDeinit();
82 LnnDeinitLnnLooper();
83 LnnDeinitLocalLedger();
84 LnnDeinitDistributedLedger();
85 (void)memset_s(&g_nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
86 GTEST_LOG_(INFO) << "LaneTest end";
87 }
88
SetUp()89 void LaneTest::SetUp() { }
90
TearDown()91 void LaneTest::TearDown() { }
92
ConstructRemoteNode(void)93 static void ConstructRemoteNode(void)
94 {
95 (void)memset_s(&g_nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
96 uint32_t cap = 0;
97 LnnSetNetCapability(&cap, BIT_BR);
98 LnnSetNetCapability(&cap, BIT_WIFI_P2P);
99 LnnSetNetCapability(&cap, BIT_WIFI_24G);
100 LnnSetNetCapability(&cap, BIT_WIFI_5G);
101 g_nodeInfo.netCapacity = cap;
102 int32_t ret = strncpy_s(g_nodeInfo.networkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID, strlen(NODE_NETWORK_ID));
103 EXPECT_TRUE(ret == EOK);
104 ret = LnnSetDeviceUdid(&g_nodeInfo, NODE_UDID);
105 EXPECT_TRUE(ret == SOFTBUS_OK);
106 ret = LnnSetDiscoveryType(&g_nodeInfo, DISCOVERY_TYPE_WIFI);
107 EXPECT_TRUE(ret == SOFTBUS_OK);
108 ret = LnnSetProxyPort(&g_nodeInfo, REMOTE_PROXY_PORT, WLAN_IF);
109 EXPECT_TRUE(ret == SOFTBUS_OK);
110 ret = LnnSetSessionPort(&g_nodeInfo, REMOTE_SESSION_PORT, WLAN_IF);
111 EXPECT_TRUE(ret == SOFTBUS_OK);
112 LnnSetWiFiIp(&g_nodeInfo, REMOTE_WLAN_IP, WLAN_IF);
113 ret = LnnSetAuthPort(&g_nodeInfo, REMOTE_AUTH_PORT, WLAN_IF);
114 EXPECT_TRUE(ret == SOFTBUS_OK);
115 LnnSetBtMac(&g_nodeInfo, NODE_BT_MAC);
116 (void)LnnAddOnlineNode(&g_nodeInfo);
117 }
118
ConstructLocalInfo(void)119 static void ConstructLocalInfo(void)
120 {
121 int32_t ret = LnnSetLocalStrInfo(STRING_KEY_NETWORKID, LOCAL_NETWORK_ID);
122 EXPECT_TRUE(ret == SOFTBUS_OK);
123 ret = LnnSetLocalNumInfo(
124 NUM_KEY_NET_CAP, (1 << BIT_BR) | (1 << BIT_WIFI_24G) | (1 << BIT_WIFI_5G) | (1 << BIT_WIFI_P2P));
125 EXPECT_TRUE(ret == SOFTBUS_OK);
126 }
127
NotifyWlanLinkSuccess(uint32_t reqId,LaneLinkType linkType,const LaneLinkInfo * linkInfo)128 static void NotifyWlanLinkSuccess(uint32_t reqId, LaneLinkType linkType, const LaneLinkInfo *linkInfo)
129 {
130 EXPECT_TRUE((linkInfo->type == LANE_WLAN_2P4G) || (linkInfo->type == LANE_WLAN_5G));
131 EXPECT_EQ(linkInfo->linkInfo.wlan.connInfo.port, REMOTE_SESSION_PORT);
132 EXPECT_STREQ(REMOTE_WLAN_IP, linkInfo->linkInfo.wlan.connInfo.addr);
133 printf("WLAN: linkSuccess, reqId:0x%x\n", reqId);
134 }
135
NotifyWlanLinkFail(uint32_t reqId,int32_t reason,LaneLinkType linkType)136 static void NotifyWlanLinkFail(uint32_t reqId, int32_t reason, LaneLinkType linkType)
137 {
138 printf("WLAN: reqId:0x%x, fail reason:%d, linkType:%d\n", reqId, reason, linkType);
139 }
140
NotifyBrLinkSuccess(uint32_t reqId,LaneLinkType linkType,const LaneLinkInfo * linkInfo)141 static void NotifyBrLinkSuccess(uint32_t reqId, LaneLinkType linkType, const LaneLinkInfo *linkInfo)
142 {
143 EXPECT_TRUE(linkInfo->type == LANE_BR);
144 EXPECT_STREQ(linkInfo->linkInfo.br.brMac, NODE_BT_MAC);
145 printf("BR: linkSuccess, reqId:0x%x\n", reqId);
146 }
147
NotifyBrLinkFail(uint32_t reqId,int32_t reason,LaneLinkType linkType)148 static void NotifyBrLinkFail(uint32_t reqId, int32_t reason, LaneLinkType linkType)
149 {
150 printf("BR: reqId:0x%x, fail reason:%d, linkType:%d\n", reqId, reason, linkType);
151 }
152
153 /*
154 * @tc.name: LANE_REQ_ID_APPLY_Test_001
155 * @tc.desc: apply laneReqId test
156 * @tc.type: FUNC
157 * @tc.require: I5FBFG
158 */
159 HWTEST_F(LaneTest, LANE_REQ_ID_APPLY_Test_001, TestSize.Level1)
160 {
161 const LnnLaneManager *laneManager = GetLaneManager();
162 LaneType laneType = LANE_TYPE_TRANS;
163 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
164 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
165 EXPECT_EQ(laneType, laneReqId >> LANE_REQID_TYPE_SHIFT);
166 FreeLaneReqId(laneReqId);
167 }
168
169 /*
170 * @tc.name: LANE_REQ_ID_APPLY_Test_002
171 * @tc.desc: apply laneReqId test
172 * @tc.type: FUNC
173 * @tc.require: I5FBFG
174 */
175 HWTEST_F(LaneTest, LANE_REQ_ID_APPLY_Test_002, TestSize.Level1)
176 {
177 LaneType laneType = LANE_TYPE_TRANS;
178 uint32_t laneReqId;
179 uint32_t *laneReqIdList = (uint32_t *)SoftBusCalloc(sizeof(uint32_t) * MAX_LANE_REQ_ID_NUM);
180 if (laneReqIdList == nullptr) {
181 return;
182 }
183 const LnnLaneManager *laneManager = GetLaneManager();
184 uint32_t i;
185 for (i = 0; i < MAX_LANE_REQ_ID_NUM; i++) {
186 laneReqId = laneManager->lnnGetLaneHandle(laneType);
187 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
188 laneReqIdList[i] = laneReqId;
189 }
190 laneReqId = laneManager->lnnGetLaneHandle(laneType);
191 EXPECT_TRUE(laneReqId == INVALID_LANE_REQ_ID);
192 for (i = 0; i < MAX_LANE_REQ_ID_NUM; i++) {
193 FreeLaneReqId(laneReqIdList[i]);
194 }
195 SoftBusFree(laneReqIdList);
196 }
197
198
199 /*
200 * @tc.name: LANE_LINK_Test_001
201 * @tc.desc: LaneLink of wlan5G
202 * @tc.type: FUNC
203 * @tc.require: I5FBFG
204 */
205 HWTEST_F(LaneTest, LANE_LINK_Test_001, TestSize.Level1)
206 {
207 ConnServerInit();
208 InitLaneReliability();
209 LinkRequest reqInfo;
210 (void)memset_s(&reqInfo, sizeof(LinkRequest), 0, sizeof(LinkRequest));
211 int32_t ret = memcpy_s(reqInfo.peerNetworkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID, strlen(NODE_NETWORK_ID));
212 EXPECT_TRUE(ret == EOK);
213 reqInfo.linkType = LANE_WLAN_2P4G;
214 reqInfo.transType = LANE_T_BYTE;
215 reqInfo.pid = DEFAULT_PID;
216 LaneLinkCb linkCb = {
217 .onLaneLinkSuccess = NotifyWlanLinkSuccess,
218 .onLaneLinkFail = NotifyWlanLinkFail,
219 };
220 uint32_t requestId = 0x5A5A;
221 ret = BuildLink(&reqInfo, requestId, &linkCb);
222 EXPECT_EQ(ret, SOFTBUS_TCPCONNECTION_SOCKET_ERR);
223 ConnServerDeinit();
224 }
225
226 /*
227 * @tc.name: LANE_LINK_Test_002
228 * @tc.desc: LaneLink of BR
229 * @tc.type: FUNC
230 * @tc.require: I5FBFG
231 */
232 HWTEST_F(LaneTest, LANE_LINK_Test_002, TestSize.Level1)
233 {
234 LinkRequest reqInfo;
235 (void)memset_s(&reqInfo, sizeof(LinkRequest), 0, sizeof(LinkRequest));
236 int32_t ret = memcpy_s(reqInfo.peerNetworkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID, strlen(NODE_NETWORK_ID));
237 EXPECT_EQ(ret, EOK);
238 reqInfo.linkType = LANE_BR;
239 reqInfo.transType = LANE_T_BYTE;
240 reqInfo.pid = DEFAULT_PID;
241 LaneLinkCb linkCb = {
242 .onLaneLinkSuccess = NotifyBrLinkSuccess,
243 .onLaneLinkFail = NotifyBrLinkFail,
244 };
245 uint32_t requestId = 0x5A5A;
246 ret = BuildLink(&reqInfo, requestId, &linkCb);
247 EXPECT_EQ(ret, SOFTBUS_OK);
248 }
249
250 /*
251 * @tc.name: ADD_LANE_RESOURCE_TO_POOL_Test_001
252 * @tc.desc: AddLaneResourceToPool test
253 * @tc.type: FUNC
254 * @tc.require: I5FBFG
255 */
256 HWTEST_F(LaneTest, ADD_LANE_RESOURCE_TO_POOL_Test_001, TestSize.Level1)
257 {
258 LaneLinkInfo linkInfo = {
259 .type = LANE_HML,
260 };
261 EXPECT_EQ(strncpy_s(linkInfo.peerUdid, UDID_BUF_LEN, NODE_UDID, UDID_BUF_LEN), EOK);
262 EXPECT_EQ(strncpy_s(linkInfo.linkInfo.p2p.connInfo.peerIp, IP_LEN, REMOTE_WLAN_IP, IP_LEN), EOK);
263 EXPECT_EQ(AddLaneResourceToPool(&linkInfo, LANE_ID, true), SOFTBUS_OK);
264 linkInfo.type = LANE_BR;
265 EXPECT_EQ(strncpy_s(linkInfo.linkInfo.br.brMac, BT_MAC_LEN, NODE_BT_MAC, BT_MAC_LEN), EOK);
266 EXPECT_EQ(AddLaneResourceToPool(&linkInfo, LANE_ID, true), SOFTBUS_OK);
267 linkInfo.type = LANE_BLE;
268 EXPECT_EQ(strncpy_s(linkInfo.linkInfo.ble.bleMac, BT_MAC_LEN, NODE_BT_MAC, BT_MAC_LEN), EOK);
269 EXPECT_EQ(AddLaneResourceToPool(&linkInfo, LANE_ID, true), SOFTBUS_OK);
270 linkInfo.type = LANE_BLE_DIRECT;
271 EXPECT_EQ(strcpy_s(linkInfo.linkInfo.bleDirect.networkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID), EOK);
272 EXPECT_EQ(AddLaneResourceToPool(&linkInfo, LANE_ID, true), SOFTBUS_OK);
273 linkInfo.type = LANE_WLAN_5G;
274 EXPECT_EQ(AddLaneResourceToPool(&linkInfo, LANE_ID, true), SOFTBUS_OK);
275 EXPECT_EQ(AddLaneResourceToPool(nullptr, LANE_ID, true), SOFTBUS_INVALID_PARAM);
276 EXPECT_EQ(AddLaneResourceToPool(&linkInfo, INVALID_LANE_ID, true), SOFTBUS_INVALID_PARAM);
277 }
278
279 /*
280 * @tc.name: CHECK_LANE_RESOURCE_NUM_BY_LINK_TYPE_Test_001
281 * @tc.desc: CheckLaneResourceNumByLinkType test
282 * @tc.type: FUNC
283 * @tc.require: I5FBFG
284 */
285 HWTEST_F(LaneTest, CHECK_LANE_RESOURCE_NUM_BY_LINK_TYPE_Test_001, TestSize.Level1)
286 {
287 const char *peerUdid = "123456ABCDEF";
288 EXPECT_EQ(InitLaneLink(), SOFTBUS_OK);
289 int32_t laneNum = 0;
290 EXPECT_EQ(CheckLaneResourceNumByLinkType(peerUdid, LANE_HML, &laneNum), SOFTBUS_NOT_FIND);
291 EXPECT_EQ(CheckLaneResourceNumByLinkType(nullptr, LANE_HML, &laneNum), SOFTBUS_INVALID_PARAM);
292 EXPECT_EQ(CheckLaneResourceNumByLinkType(peerUdid, LANE_LINK_TYPE_BUTT, &laneNum), SOFTBUS_INVALID_PARAM);
293 EXPECT_EQ(CheckLaneResourceNumByLinkType(peerUdid, LANE_HML_RAW, &laneNum), SOFTBUS_NOT_FIND);
294 }
295
296 /*
297 * @tc.name: UPDATE_LANE_RESOURCE_LANE_ID_Test_001
298 * @tc.desc: UpdateLaneResourceLaneId test
299 * @tc.type: FUNC
300 * @tc.require: I5FBFG
301 */
302 HWTEST_F(LaneTest, UPDATE_LANE_RESOURCE_LANE_ID_Test_001, TestSize.Level1)
303 {
304 uint64_t oldLaneId = LANE_ID;
305 uint64_t newLaneId = LANE_ID + 1;
306 const char *peerUdid = "123456ABCDEF";
307 const char *peerUdid1 = "123456ABCDEFGHIGK";
308 EXPECT_EQ(UpdateLaneResourceLaneId(oldLaneId, newLaneId, peerUdid), SOFTBUS_NOT_FIND);
309 EXPECT_EQ(UpdateLaneResourceLaneId(oldLaneId, newLaneId, peerUdid1), SOFTBUS_NOT_FIND);
310 EXPECT_EQ(UpdateLaneResourceLaneId(INVALID_LANE_ID, newLaneId, peerUdid1), SOFTBUS_INVALID_PARAM);
311 EXPECT_EQ(UpdateLaneResourceLaneId(oldLaneId, INVALID_LANE_ID, peerUdid1), SOFTBUS_INVALID_PARAM);
312 EXPECT_EQ(UpdateLaneResourceLaneId(oldLaneId, INVALID_LANE_ID, nullptr), SOFTBUS_INVALID_PARAM);
313 }
314
315 /*
316 * @tc.name: DESTROY_LINK_Test_001
317 * @tc.desc: DestroyLink test
318 * @tc.type: FUNC
319 * @tc.require: I5FBFG
320 */
321 HWTEST_F(LaneTest, DESTROY_LINK_Test_001, TestSize.Level1)
322 {
323 uint32_t laneReqId = LANE_REQID_TYPE_SHIFT;
324 EXPECT_EQ(DestroyLink(nullptr, laneReqId, LANE_P2P), SOFTBUS_INVALID_PARAM);
325 }
326 } // namespace OHOS
327