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 <thread>
17 #include <gmock/gmock.h>
18 #include <gtest/gtest.h>
19 #include <securec.h>
20
21 #include "lnn_ctrl_lane.h"
22 #include "lnn_ctrl_lane_deps_mock.h"
23 #include "lnn_lane_deps_mock.h"
24 #include "lnn_lane_interface.h"
25 #include "softbus_error_code.h"
26
27 namespace OHOS {
28 using namespace testing::ext;
29 using namespace testing;
30
31 constexpr uint64_t LANE_ID = 1122334455667788;
32 constexpr char NETWORK_ID[] = "123456789";
33 constexpr char UDID[] = "1122334455667788";
34 static int32_t g_errCode = SOFTBUS_LANE_ERR_BASE;
35
OnLaneAllocSuccess(uint32_t laneHandle,const LaneConnInfo * info)36 static void OnLaneAllocSuccess(uint32_t laneHandle, const LaneConnInfo *info)
37 {
38 ASSERT_NE(info, nullptr) << "invalid info";
39 g_errCode = SOFTBUS_OK;
40 }
41
OnLaneAllocFail(uint32_t laneHandle,int32_t errCode)42 static void OnLaneAllocFail(uint32_t laneHandle, int32_t errCode)
43 {
44 GTEST_LOG_(INFO) << "alloc lane failed, laneReqId=" << laneHandle << ", errCode=" << errCode;
45 g_errCode = errCode;
46 }
47
OnLaneFreeSuccess(uint32_t laneHandle)48 static void OnLaneFreeSuccess(uint32_t laneHandle)
49 {
50 GTEST_LOG_(INFO) << "free lane success, laneReqId=" << laneHandle;
51 }
52
OnLaneFreeFail(uint32_t laneHandle,int32_t errCode)53 static void OnLaneFreeFail(uint32_t laneHandle, int32_t errCode)
54 {
55 GTEST_LOG_(INFO) << "free lane failed, laneReqId=" << laneHandle << ", errCode=" << errCode;
56 }
57
58 static LaneAllocListener g_listener = {
59 .onLaneAllocSuccess = OnLaneAllocSuccess,
60 .onLaneAllocFail = OnLaneAllocFail,
61 .onLaneFreeSuccess = OnLaneFreeSuccess,
62 .onLaneFreeFail = OnLaneFreeFail,
63 };
64
IsNegotiateChannelNeeded(const char * remoteNetworkId,enum WifiDirectLinkType linkType)65 static bool IsNegotiateChannelNeeded(const char *remoteNetworkId, enum WifiDirectLinkType linkType)
66 {
67 return false;
68 }
69
70 static struct WifiDirectManager g_manager = {
71 .isNegotiateChannelNeeded= IsNegotiateChannelNeeded,
72 };
73
74 class LNNCtrlLaneMockTest : public testing::Test {
75 public:
76 static void SetUpTestCase();
77 static void TearDownTestCase();
78 void SetUp();
79 void TearDown();
80 };
81
SetUpTestCase()82 void LNNCtrlLaneMockTest::SetUpTestCase()
83 {
84 GTEST_LOG_(INFO) << "LNNCtrlLaneMockTest start";
85 LnnInitLnnLooper();
86 }
87
TearDownTestCase()88 void LNNCtrlLaneMockTest::TearDownTestCase()
89 {
90 LnnDeinitLnnLooper();
91 GTEST_LOG_(INFO) << "LNNCtrlLaneMockTest end";
92 }
93
SetUp()94 void LNNCtrlLaneMockTest::SetUp()
95 {
96 }
97
TearDown()98 void LNNCtrlLaneMockTest::TearDown()
99 {
100 }
101
102 /*
103 * @tc.name: LNN_CRTL_ALLOC_LANE_001
104 * @tc.desc: ctrl alloclane -> test param check
105 * @tc.type: FUNC
106 * @tc.require:
107 */
108 HWTEST_F(LNNCtrlLaneMockTest, LNN_CRTL_ALLOC_LANE_001, TestSize.Level1)
109 {
110 LaneInterface *ctrlObj = CtrlLaneGetInstance();
111 EXPECT_TRUE(ctrlObj != nullptr);
112 ctrlObj->deinit();
113 ctrlObj->init(nullptr);
114 ctrlObj->init(nullptr);
115
116 uint32_t laneReqId = 1;
117 int32_t ret = ctrlObj->allocLaneByQos(INVALID_LANE_REQ_ID, nullptr, nullptr);
118 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
119
120 ret = ctrlObj->allocLaneByQos(laneReqId, nullptr, nullptr);
121 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
122
123 LaneAllocInfo info = {};
124 info.type = LANE_TYPE_BUTT;
125 ret = ctrlObj->allocLaneByQos(laneReqId, &info, nullptr);
126 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
127 ctrlObj->deinit();
128 }
129
130 /*
131 * @tc.name: LNN_CRTL_ALLOC_LANE_002
132 * @tc.desc: ctrl alloclane -> test ConvertAuthLinkToLaneLink(wifi/br/ble)
133 * @tc.type: FUNC
134 * @tc.require:
135 */
136 HWTEST_F(LNNCtrlLaneMockTest, LNN_CRTL_ALLOC_LANE_002, TestSize.Level1)
137 {
138 LaneInterface *ctrlObj = CtrlLaneGetInstance();
139 EXPECT_TRUE(ctrlObj != nullptr);
140 ctrlObj->init(nullptr);
141
142 AuthLinkTypeList authList = {};
143 authList.linkTypeNum = 1;
144 authList.linkType[0] = AUTH_LINK_TYPE_WIFI;
145 NiceMock<CtrlLaneDepsInterfaceMock> ctrlMock;
146 NiceMock<LaneDepsInterfaceMock> laneMock;
147 EXPECT_CALL(laneMock, GetAuthLinkTypeList).WillOnce(Return(SOFTBUS_INVALID_PARAM))
148 .WillOnce(DoAll(SetArgPointee<1>(authList), Return(SOFTBUS_OK)));
149 EXPECT_CALL(ctrlMock, SelectAuthLane).WillRepeatedly(Return(SOFTBUS_LANE_NO_AVAILABLE_LINK));
150 EXPECT_CALL(ctrlMock, FreeLaneReqId).WillRepeatedly(Return());
151 uint32_t laneReqId = 1;
152 LaneAllocInfo info = {};
153 info.type = LANE_TYPE_CTRL;
154 int32_t ret = ctrlObj->allocLaneByQos(laneReqId, &info, &g_listener);
155 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
156 ret = ctrlObj->allocLaneByQos(laneReqId, &info, &g_listener);
157 EXPECT_EQ(ret, SOFTBUS_LANE_NO_AVAILABLE_LINK);
158
159 authList.linkType[0] = AUTH_LINK_TYPE_BR;
160 EXPECT_CALL(laneMock, GetAuthLinkTypeList)
161 .WillOnce(DoAll(SetArgPointee<1>(authList), Return(SOFTBUS_OK)));
162 ret = ctrlObj->allocLaneByQos(laneReqId, &info, &g_listener);
163 EXPECT_EQ(ret, SOFTBUS_LANE_NO_AVAILABLE_LINK);
164
165 authList.linkType[0] = AUTH_LINK_TYPE_BLE;
166 EXPECT_CALL(laneMock, GetAuthLinkTypeList)
167 .WillOnce(DoAll(SetArgPointee<1>(authList), Return(SOFTBUS_OK)));
168 ret = ctrlObj->allocLaneByQos(laneReqId, &info, &g_listener);
169 EXPECT_EQ(ret, SOFTBUS_LANE_NO_AVAILABLE_LINK);
170 ctrlObj->deinit();
171 }
172
173 /*
174 * @tc.name: LNN_CRTL_ALLOC_LANE_003
175 * @tc.desc: ctrl alloclane -> test ConvertAuthLinkToLaneLink(p2p/enhanced_p2p/max)
176 * @tc.type: FUNC
177 * @tc.require:
178 */
179 HWTEST_F(LNNCtrlLaneMockTest, LNN_CRTL_ALLOC_LANE_003, TestSize.Level1)
180 {
181 LaneInterface *ctrlObj = CtrlLaneGetInstance();
182 EXPECT_TRUE(ctrlObj != nullptr);
183 ctrlObj->init(nullptr);
184
185 AuthLinkTypeList authList = {};
186 authList.linkTypeNum = 1;
187 authList.linkType[0] = AUTH_LINK_TYPE_P2P;
188 NiceMock<CtrlLaneDepsInterfaceMock> ctrlMock;
189 NiceMock<LaneDepsInterfaceMock> laneMock;
190 EXPECT_CALL(laneMock, GetAuthLinkTypeList).WillOnce(Return(SOFTBUS_INVALID_PARAM))
191 .WillOnce(DoAll(SetArgPointee<1>(authList), Return(SOFTBUS_OK)));
192 EXPECT_CALL(ctrlMock, SelectAuthLane).WillRepeatedly(Return(SOFTBUS_LANE_NO_AVAILABLE_LINK));
193 EXPECT_CALL(ctrlMock, FreeLaneReqId).WillRepeatedly(Return());
194 uint32_t laneReqId = 1;
195 LaneAllocInfo info = {};
196 info.type = LANE_TYPE_CTRL;
197 int32_t ret = ctrlObj->allocLaneByQos(laneReqId, &info, &g_listener);
198 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
199 ret = ctrlObj->allocLaneByQos(laneReqId, &info, &g_listener);
200 EXPECT_EQ(ret, SOFTBUS_LANE_NO_AVAILABLE_LINK);
201
202 authList.linkType[0] = AUTH_LINK_TYPE_ENHANCED_P2P;
203 EXPECT_CALL(laneMock, GetAuthLinkTypeList)
204 .WillOnce(DoAll(SetArgPointee<1>(authList), Return(SOFTBUS_OK)));
205 ret = ctrlObj->allocLaneByQos(laneReqId, &info, &g_listener);
206 EXPECT_EQ(ret, SOFTBUS_LANE_NO_AVAILABLE_LINK);
207
208 authList.linkType[0] = AUTH_LINK_TYPE_MAX;
209 EXPECT_CALL(laneMock, GetAuthLinkTypeList)
210 .WillOnce(DoAll(SetArgPointee<1>(authList), Return(SOFTBUS_OK)));
211 ret = ctrlObj->allocLaneByQos(laneReqId, &info, &g_listener);
212 EXPECT_EQ(ret, SOFTBUS_LANE_NO_AVAILABLE_LINK);
213 ctrlObj->deinit();
214 }
215
216 /*
217 * @tc.name: LNN_CRTL_ALLOC_LANE_004
218 * @tc.desc: ctrl alloclane -> test build fail
219 * @tc.type: FUNC
220 * @tc.require:
221 */
222 HWTEST_F(LNNCtrlLaneMockTest, LNN_CRTL_ALLOC_LANE_004, TestSize.Level1)
223 {
224 LaneInterface *ctrlObj = CtrlLaneGetInstance();
225 EXPECT_TRUE(ctrlObj != nullptr);
226 ctrlObj->init(nullptr);
227
228 AuthLinkTypeList authList = {};
229 authList.linkTypeNum = 1;
230 authList.linkType[0] = AUTH_LINK_TYPE_WIFI;
231 NiceMock<CtrlLaneDepsInterfaceMock> ctrlMock;
232 NiceMock<LaneDepsInterfaceMock> laneMock;
233 EXPECT_CALL(laneMock, GetAuthLinkTypeList).WillRepeatedly(DoAll(SetArgPointee<1>(authList), Return(SOFTBUS_OK)));
234 EXPECT_CALL(ctrlMock, SelectAuthLane).WillRepeatedly(Return(SOFTBUS_OK));
235 EXPECT_CALL(ctrlMock, BuildLink).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
236 EXPECT_CALL(ctrlMock, FreeLaneReqId).WillRepeatedly(Return());
237 uint32_t laneReqId = 1;
238 LaneAllocInfo info = {};
239 info.type = LANE_TYPE_CTRL;
240 g_errCode = SOFTBUS_LANE_ERR_BASE;
241 int32_t ret = ctrlObj->allocLaneByQos(laneReqId, &info, &g_listener);
242 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
243 EXPECT_EQ(g_errCode, SOFTBUS_INVALID_PARAM);
244 ctrlObj->deinit();
245 }
246
247 /*
248 * @tc.name: LNN_CRTL_ALLOC_LANE_005
249 * @tc.desc: ctrl alloclane -> test build success
250 * @tc.type: FUNC
251 * @tc.require:
252 */
253 HWTEST_F(LNNCtrlLaneMockTest, LNN_CRTL_ALLOC_LANE_005, TestSize.Level1)
254 {
255 LaneInterface *ctrlObj = CtrlLaneGetInstance();
256 EXPECT_TRUE(ctrlObj != nullptr);
257 ctrlObj->init(nullptr);
258
259 AuthLinkTypeList authList = {};
260 authList.linkTypeNum = 1;
261 authList.linkType[0] = AUTH_LINK_TYPE_WIFI;
262 NiceMock<CtrlLaneDepsInterfaceMock> ctrlMock;
263 NiceMock<LaneDepsInterfaceMock> laneMock;
264 EXPECT_CALL(laneMock, GetAuthLinkTypeList).WillRepeatedly(DoAll(SetArgPointee<1>(authList), Return(SOFTBUS_OK)));
265 EXPECT_CALL(ctrlMock, SelectAuthLane).WillRepeatedly(Return(SOFTBUS_OK));
266 EXPECT_CALL(ctrlMock, BuildLink(_, _, NotNull())).WillRepeatedly(ctrlMock.BuildLinkSuccess);
267 EXPECT_CALL(ctrlMock, GenerateLaneId).WillOnce(Return(INVALID_LANE_ID)).WillRepeatedly(Return(LANE_ID));
268 EXPECT_CALL(ctrlMock, FreeLaneReqId).WillRepeatedly(Return());
269 EXPECT_CALL(ctrlMock, AddLaneResourceToPool).WillOnce(Return(SOFTBUS_INVALID_PARAM))
270 .WillRepeatedly(Return(SOFTBUS_OK));
271 EXPECT_CALL(ctrlMock, LaneInfoProcess).WillOnce(Return(SOFTBUS_INVALID_PARAM)).WillRepeatedly(Return(SOFTBUS_OK));
272 EXPECT_CALL(laneMock, LnnGetLocalStrInfo).WillOnce(Return(SOFTBUS_INVALID_PARAM))
273 .WillRepeatedly(Return(SOFTBUS_OK));
274 uint32_t laneReqId = 1;
275 LaneAllocInfo info = {};
276 info.type = LANE_TYPE_CTRL;
277 g_errCode = SOFTBUS_LANE_ERR_BASE;
278 int32_t ret = ctrlObj->allocLaneByQos(laneReqId, &info, &g_listener);
279 EXPECT_EQ(ret, SOFTBUS_OK);
280 EXPECT_EQ(g_errCode, SOFTBUS_LANE_GET_LEDGER_INFO_ERR);
281
282 ret = ctrlObj->allocLaneByQos(laneReqId, &info, &g_listener);
283 EXPECT_EQ(ret, SOFTBUS_OK);
284 EXPECT_EQ(g_errCode, SOFTBUS_LANE_ID_GENERATE_FAIL);
285
286 ret = ctrlObj->allocLaneByQos(laneReqId, &info, &g_listener);
287 EXPECT_EQ(ret, SOFTBUS_OK);
288 EXPECT_EQ(g_errCode, SOFTBUS_INVALID_PARAM);
289
290 g_errCode = SOFTBUS_LANE_ERR_BASE;
291 ret = ctrlObj->allocLaneByQos(laneReqId, &info, &g_listener);
292 EXPECT_EQ(ret, SOFTBUS_OK);
293 EXPECT_EQ(g_errCode, SOFTBUS_LANE_ERR_BASE);
294
295 ret = ctrlObj->allocLaneByQos(laneReqId, &info, &g_listener);
296 EXPECT_EQ(ret, SOFTBUS_OK);
297 EXPECT_EQ(g_errCode, SOFTBUS_OK);
298 ctrlObj->deinit();
299 }
300
301 /*
302 * @tc.name: LNN_CRTL_ALLOC_LANE_006
303 * @tc.desc: ctrl alloclane -> test free
304 * @tc.type: FUNC
305 * @tc.require:
306 */
307 HWTEST_F(LNNCtrlLaneMockTest, LNN_CRTL_ALLOC_LANE_006, TestSize.Level1)
308 {
309 LaneInterface *ctrlObj = CtrlLaneGetInstance();
310 EXPECT_TRUE(ctrlObj != nullptr);
311 ctrlObj->init(nullptr);
312
313 AuthLinkTypeList authList = {};
314 authList.linkTypeNum = 1;
315 authList.linkType[0] = AUTH_LINK_TYPE_WIFI;
316 NiceMock<CtrlLaneDepsInterfaceMock> ctrlMock;
317 NiceMock<LaneDepsInterfaceMock> laneMock;
318 EXPECT_CALL(laneMock, GetAuthLinkTypeList).WillRepeatedly(DoAll(SetArgPointee<1>(authList), Return(SOFTBUS_OK)));
319 EXPECT_CALL(ctrlMock, SelectAuthLane).WillRepeatedly(Return(SOFTBUS_OK));
320 EXPECT_CALL(ctrlMock, BuildLink(_, _, NotNull())).WillRepeatedly(ctrlMock.BuildLinkSuccess);
321 EXPECT_CALL(ctrlMock, DestroyLink).WillRepeatedly(Return(SOFTBUS_OK));
322 EXPECT_CALL(ctrlMock, GenerateLaneId).WillRepeatedly(Return(LANE_ID));
323 EXPECT_CALL(ctrlMock, AddLaneResourceToPool).WillRepeatedly(Return(SOFTBUS_OK));
324 EXPECT_CALL(ctrlMock, DelLaneResourceByLaneId).WillRepeatedly(Return(SOFTBUS_OK));
325 EXPECT_CALL(ctrlMock, FindLaneResourceByLaneId).WillRepeatedly(Return(SOFTBUS_OK));
326 EXPECT_CALL(ctrlMock, FreeLaneReqId).WillRepeatedly(Return());
327 EXPECT_CALL(ctrlMock, LaneInfoProcess).WillRepeatedly(Return(SOFTBUS_OK));
328 EXPECT_CALL(laneMock, LnnGetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
329 EXPECT_CALL(laneMock, LnnGetNetworkIdByUdid).WillOnce(Return(SOFTBUS_INVALID_PARAM))
330 .WillRepeatedly(Return(SOFTBUS_OK));
331 uint32_t laneReqId = 1;
332 LaneAllocInfo info = {};
333 info.type = LANE_TYPE_CTRL;
334 g_errCode = SOFTBUS_LANE_ERR_BASE;
335 int32_t ret = ctrlObj->allocLaneByQos(laneReqId, &info, &g_listener);
336 EXPECT_EQ(ret, SOFTBUS_OK);
337 EXPECT_EQ(g_errCode, SOFTBUS_OK);
338 ret = ctrlObj->freeLane(laneReqId);
339 EXPECT_EQ(ret, SOFTBUS_OK);
340 g_errCode = SOFTBUS_LANE_ERR_BASE;
341 ret = ctrlObj->allocLaneByQos(laneReqId, &info, &g_listener);
342 EXPECT_EQ(ret, SOFTBUS_OK);
343 EXPECT_EQ(g_errCode, SOFTBUS_OK);
344 ret = ctrlObj->freeLane(laneReqId);
345 EXPECT_EQ(ret, SOFTBUS_OK);
346 ret = ctrlObj->freeLane(laneReqId);
347 EXPECT_EQ(ret, SOFTBUS_OK);
348 ctrlObj->deinit();
349 }
350
351 /*
352 * @tc.name: LNN_CRTL_IS_AUTH_REUSE_P2P_001
353 * @tc.desc: test IsAuthReuseP2p
354 * @tc.type: FUNC
355 * @tc.require:
356 */
357 HWTEST_F(LNNCtrlLaneMockTest, LNN_CRTL_IS_AUTH_REUSE_P2P_001, TestSize.Level1)
358 {
359 NiceMock<CtrlLaneDepsInterfaceMock> ctrlMock;
360 NiceMock<LaneDepsInterfaceMock> laneMock;
361 EXPECT_CALL(ctrlMock, FindLaneResourceByLinkType).WillRepeatedly(Return(SOFTBUS_OK));
362 EXPECT_CALL(laneMock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
363 bool ret = IsAuthReuseP2p(NETWORK_ID, UDID, AUTH_LINK_TYPE_ENHANCED_P2P);
364 EXPECT_TRUE(ret);
365 ret = IsAuthReuseP2p(NETWORK_ID, UDID, AUTH_LINK_TYPE_P2P);
366 EXPECT_TRUE(ret);
367 ret = IsAuthReuseP2p(NETWORK_ID, UDID, AUTH_LINK_TYPE_MAX);
368 EXPECT_FALSE(ret);
369 }
370 } // namespace OHOS
371