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 "auth_device.c"
22 #include "auth_interface.c"
23 #include "auth_interface.h"
24 #include "auth_lane.c"
25 #include "auth_lane_mock.h"
26 #include "auth_log.h"
27 #include "auth_manager.c"
28 #include "auth_manager.h"
29 #include "lnn_lane_common.h"
30 #include "lnn_trans_lane.h"
31
32 using namespace testing::ext;
33 using namespace testing;
34
35 namespace OHOS {
36
37 const uint64_t CONN_ID = 10 | ((uint64_t)AUTH_LINK_TYPE_WIFI << INT32_BIT_NUM);
38 constexpr char NETWORK_ID[] = "testnetworkid123";
39 constexpr char UUID_TEST[UUID_BUF_LEN] = "testId123";
40 constexpr char UDID_TEST[UDID_BUF_LEN] = "testId123";
41 constexpr char IP_TEST[IP_LEN] = "192.168.51.170";
42 constexpr char BR_MAC[BT_MAC_LEN] = "00:15:5d:de:d4:23";
43 constexpr char BLE_MAC[BT_MAC_LEN] = "00:15:5d:de:d4:23";
44 constexpr uint8_t DEVICE_ID_HASH[UDID_HASH_LEN] = "123456789";
45 constexpr int64_t AUTH_SEQ = 1;
46 constexpr int32_t DEVICE_ID_HASH_LEN = 9;
47 constexpr int32_t PORT = 1;
48
OnConnOpenedTest(uint32_t requestId,AuthHandle authHandle)49 static void OnConnOpenedTest(uint32_t requestId, AuthHandle authHandle)
50 {
51 (void)requestId;
52 (void)authHandle;
53 AUTH_LOGI(
54 AUTH_TEST, "OnConnOpenedTest: requestId=%{public}d, authId=%{public}" PRId64 "", requestId, authHandle.authId);
55 }
56
OnConnOpenFailedTest(uint32_t requestId,int32_t reason)57 static void OnConnOpenFailedTest(uint32_t requestId, int32_t reason)
58 {
59 (void)requestId;
60 (void)reason;
61 AUTH_LOGI(AUTH_TEST, "OnConnOpenFailedTest: requestId=%{public}d, reason=%{public}d.", requestId, reason);
62 }
63
64 static AuthConnCallback authConnCb = {
65 .onConnOpened = OnConnOpenedTest,
66 .onConnOpenFailed = OnConnOpenFailedTest,
67 };
68
69 class AuthLaneTest : public testing::Test {
70 public:
AuthLaneTest()71 AuthLaneTest() { }
~AuthLaneTest()72 ~AuthLaneTest() { }
73 static void SetUpTestCase(void);
74 static void TearDownTestCase(void);
SetUp()75 void SetUp() override { }
TearDown()76 void TearDown() override { }
77 };
78
SetUpTestCase()79 void AuthLaneTest::SetUpTestCase()
80 {
81 AuthLaneInterfaceMock mock;
82 EXPECT_CALL(mock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_OK));
83 EXPECT_CALL(mock, InitLaneListener).WillRepeatedly(Return(SOFTBUS_OK));
84 EXPECT_CALL(mock, LnnInitLocalLedger).WillRepeatedly(Return(SOFTBUS_OK));
85 SoftBusLooper loop;
86 EXPECT_CALL(mock, GetLooper).WillRepeatedly(Return(&loop));
87 EXPECT_CALL(mock, LnnAsyncCallbackDelayHelper).WillRepeatedly(Return(SOFTBUS_OK));
88 int32_t ret = LooperInit();
89 EXPECT_TRUE(ret == SOFTBUS_OK);
90 ret = LnnInitDistributedLedger();
91 EXPECT_TRUE(ret == SOFTBUS_OK);
92 ret = LnnInitLnnLooper();
93 EXPECT_EQ(ret, SOFTBUS_OK);
94 ret = InitLane();
95 EXPECT_TRUE(ret == SOFTBUS_OK);
96 GTEST_LOG_(INFO) << "AuthLaneTest start";
97 }
98
TearDownTestCase()99 void AuthLaneTest::TearDownTestCase()
100 {
101 DeinitLane();
102 LnnDeinitLocalLedger();
103 LnnDeinitDistributedLedger();
104 LooperDeinit();
105 GTEST_LOG_(INFO) << "AuthLaneTest end";
106 }
107
SetAuthSessionInfo(AuthSessionInfo * info,uint64_t connId,bool isServer,AuthLinkType type)108 static void SetAuthSessionInfo(AuthSessionInfo *info, uint64_t connId, bool isServer, AuthLinkType type)
109 {
110 (void)memset_s(info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
111 info->connId = connId;
112 info->isServer = isServer;
113 info->connInfo.type = type;
114 info->version = SOFTBUS_NEW_V2;
115 ASSERT_TRUE(memcpy_s(info->udid, UDID_BUF_LEN, UDID_TEST, strlen(UDID_TEST)) == EOK);
116 ASSERT_TRUE(memcpy_s(info->uuid, UUID_BUF_LEN, UUID_TEST, strlen(UUID_TEST)) == EOK);
117 switch (type) {
118 case AUTH_LINK_TYPE_WIFI:
119 ASSERT_TRUE(memcpy_s(info->connInfo.info.ipInfo.ip, IP_LEN, IP_TEST, strlen(IP_TEST)) == EOK);
120 break;
121 case AUTH_LINK_TYPE_BLE:
122 ASSERT_TRUE(memcpy_s(info->connInfo.info.bleInfo.bleMac, BT_MAC_LEN, BLE_MAC, strlen(BLE_MAC)) == EOK);
123 ASSERT_TRUE(memcpy_s(info->connInfo.info.bleInfo.deviceIdHash, UDID_HASH_LEN,
124 DEVICE_ID_HASH, DEVICE_ID_HASH_LEN) == EOK);
125 break;
126 case AUTH_LINK_TYPE_BR:
127 ASSERT_TRUE(memcpy_s(info->connInfo.info.brInfo.brMac, BT_MAC_LEN, BR_MAC, strlen(BR_MAC)) == EOK);
128 break;
129 case AUTH_LINK_TYPE_P2P:
130 case AUTH_LINK_TYPE_ENHANCED_P2P:
131 ASSERT_TRUE(memcpy_s(info->connInfo.info.ipInfo.ip, IP_LEN, IP_TEST, strlen(IP_TEST)) == EOK);
132 info->connInfo.info.ipInfo.port = PORT;
133 break;
134 default:
135 break;
136 }
137 }
138
139 /*
140 * @tc.name: ADD_AUTH_REQUEST_NODE_TEST_001
141 * @tc.desc: add auth request node test
142 * @tc.type: FUNC
143 * @tc.require:
144 */
145 HWTEST_F(AuthLaneTest, ADD_AUTH_REQUEST_NODE_TEST_001, TestSize.Level1)
146 {
147 uint32_t laneReqId = 1;
148 uint32_t authRequestId = 1;
149 AuthLaneInterfaceMock mock;
150 SoftBusLooper loop;
151 NodeInfo *nodeInfo = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
152 ASSERT_NE(nodeInfo, nullptr);
153 EXPECT_CALL(mock, GetLooper).WillRepeatedly(Return(&loop));
154 EXPECT_CALL(mock, LnnGetNodeInfoById).WillRepeatedly(Return(nodeInfo));
155 EXPECT_CALL(mock, LnnGetRemoteNumU32Info).WillRepeatedly(Return(SOFTBUS_OK));
156 EXPECT_CALL(mock, LnnGetLocalNumU32Info).WillRepeatedly(Return(SOFTBUS_OK));
157 EXPECT_CALL(mock, LnnGetRemoteStrInfo)
158 .WillRepeatedly(DoAll(SetArrayArgument<2>(UUID_TEST, UUID_TEST + UUID_BUF_LEN), Return(SOFTBUS_OK)));
159
160 InitAuthReqInfo();
161 ListInit(&g_authClientList);
162 ListInit(&g_authServerList);
163 AuthCommonInit();
164 int32_t ret = AddAuthReqNode(nullptr, laneReqId, authRequestId, &authConnCb);
165 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
166
167 ret = AddAuthReqNode(NETWORK_ID, INVALID_LANE_REQ_ID, authRequestId, &authConnCb);
168 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
169
170 ret = AddAuthReqNode(NETWORK_ID, laneReqId, authRequestId, nullptr);
171 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
172
173 ret = AddAuthReqNode(NETWORK_ID, laneReqId, authRequestId, &authConnCb);
174 EXPECT_TRUE(ret == SOFTBUS_OK);
175
176 LaneConnInfo info;
177 (void)memset_s(&info, sizeof(LaneConnInfo), 0, sizeof(LaneConnInfo));
178 AuthOnLaneAllocSuccess(laneReqId, &info);
179
180 AuthHandle authHandle;
181 (void)memset_s(&info, sizeof(LaneConnInfo), 0, sizeof(LaneConnInfo));
182 authHandle.authId = 1;
183 authHandle.type = AUTH_LINK_TYPE_WIFI;
184 OnAuthConnOpenedSucc(authRequestId, authHandle);
185
186 ret = DelAuthReqInfoByAuthHandle(&authHandle);
187 EXPECT_TRUE(ret == SOFTBUS_OK);
188 DestroyAuthManagerList();
189 AuthCommonDeinit();
190 DeInitAuthReqInfo();
191 }
192
193 /*
194 * @tc.name: AUTH_GET_REQUEST_OPTION_TEST_001
195 * @tc.desc: auth get request option test test
196 * @tc.type: FUNC
197 * @tc.require:
198 */
199 HWTEST_F(AuthLaneTest, AUTH_GET_REQUEST_OPTION_TEST_001, TestSize.Level1)
200 {
201 AuthLaneInterfaceMock mock;
202 EXPECT_CALL(mock, LnnGetRemoteStrInfo)
203 .WillRepeatedly(DoAll(SetArrayArgument<2>(UUID_TEST, UUID_TEST + UUID_BUF_LEN), Return(SOFTBUS_OK)));
204 LaneAllocInfo allocInfo;
205 (void)memset_s(&allocInfo, sizeof(LaneAllocInfo), 0, sizeof(LaneAllocInfo));
206
207 int32_t ret = AuthGetLaneAllocInfo(nullptr, &allocInfo);
208 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
209
210 ret = AuthGetLaneAllocInfo(NETWORK_ID, nullptr);
211 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
212
213 ret = AuthGetLaneAllocInfo(NETWORK_ID, &allocInfo);
214 EXPECT_TRUE(ret == SOFTBUS_OK);
215 }
216
217 /*
218 * @tc.name: GET_AUTH_LINK_TYPE_LIST_TEST_001
219 * @tc.desc: get auth link type list test
220 * @tc.type: FUNC
221 * @tc.require:
222 */
223 HWTEST_F(AuthLaneTest, GET_AUTH_LINK_TYPE_LIST_TEST_001, TestSize.Level1)
224 {
225 AuthLinkTypeList linkTypeList;
226 (void)memset_s(&linkTypeList, sizeof(AuthLinkTypeList), 0, sizeof(AuthLinkTypeList));
227
228 AuthLaneInterfaceMock mock;
229 EXPECT_CALL(mock, LnnGetRemoteStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
230
231 int32_t ret = GetAuthLinkTypeList(nullptr, &linkTypeList);
232 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
233
234 ret = GetAuthLinkTypeList(NETWORK_ID, nullptr);
235 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
236
237 ret = GetAuthLinkTypeList(NETWORK_ID, &linkTypeList);
238 EXPECT_NE(ret, SOFTBUS_OK);
239 }
240
241 /*
242 * @tc.name: AUTH_ALLOC_LANE_001
243 * @tc.desc: auth alloc lane test
244 * @tc.type: FUNC
245 * @tc.require:
246 */
247 HWTEST_F(AuthLaneTest, AUTH_ALLOC_LANE_001, TestSize.Level1)
248 {
249 AuthLaneInterfaceMock mock;
250 SoftBusLooper loop;
251 EXPECT_CALL(mock, GetLooper).WillRepeatedly(Return(&loop));
252 EXPECT_CALL(mock, LnnGetRemoteStrInfo)
253 .WillRepeatedly(DoAll(SetArrayArgument<2>(UUID_TEST, UUID_TEST + UUID_BUF_LEN), Return(SOFTBUS_OK)));
254 InitAuthReqInfo();
255 ListInit(&g_authClientList);
256 ListInit(&g_authServerList);
257 AuthCommonInit();
258 uint32_t authRequestId = 0;
259
260 int32_t ret = AuthAllocLane(NETWORK_ID, authRequestId, nullptr);
261 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
262
263 ret = AuthAllocLane(nullptr, authRequestId, &authConnCb);
264 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
265
266 ret = AuthAllocLane(NETWORK_ID, authRequestId, &authConnCb);
267 EXPECT_NE(ret, SOFTBUS_OK);
268 DestroyAuthManagerList();
269 AuthCommonDeinit();
270 DeInitAuthReqInfo();
271 }
272
273 /*
274 * @tc.name: AUTH_ALLOC_LANE_WLAN_001
275 * @tc.desc: auth alloc lane wlan test
276 * @tc.type: FUNC
277 * @tc.require:
278 */
279 HWTEST_F(AuthLaneTest, AUTH_ALLOC_LANE_WLAN_001, TestSize.Level1)
280 {
281 AuthLaneInterfaceMock mock;
282 SoftBusLooper loop;
283 EXPECT_CALL(mock, GetLooper).WillRepeatedly(Return(&loop));
284 EXPECT_CALL(mock, LnnGetRemoteStrInfo)
285 .WillRepeatedly(DoAll(SetArrayArgument<2>(UUID_TEST, UUID_TEST + UUID_BUF_LEN), Return(SOFTBUS_OK)));
286 InitAuthReqInfo();
287 ListInit(&g_authClientList);
288 ListInit(&g_authServerList);
289 AuthCommonInit();
290
291 AuthSessionInfo info;
292 SetAuthSessionInfo(&info, CONN_ID, false, AUTH_LINK_TYPE_WIFI);
293 EXPECT_TRUE(NewAuthManager(AUTH_SEQ, &info) != nullptr);
294 AuthConnInfo connInfo;
295 (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
296 connInfo.type = AUTH_LINK_TYPE_WIFI;
297 ASSERT_TRUE(memcpy_s(connInfo.info.ipInfo.ip, IP_LEN, IP_TEST, strlen(IP_TEST)) == EOK);
298 AuthManager *auth = FindAuthManagerByConnInfo(&connInfo, false);
299 EXPECT_TRUE(auth != nullptr);
300 auth->hasAuthPassed[AUTH_LINK_TYPE_WIFI] = true;
301 auth->authId = 1;
302 auth->lastVerifyTime = 1;
303
304 uint32_t authRequestId = AuthGenRequestId();
305 int32_t ret = AuthAllocLane(NETWORK_ID, authRequestId, &authConnCb);
306 EXPECT_NE(ret, SOFTBUS_OK);
307
308 uint32_t laneReqId = GetLaneManager()->lnnGetLaneHandle(LANE_TYPE_CTRL);
309 LaneConnInfo laneConnInfo;
310 (void)memset_s(&laneConnInfo, sizeof(LaneConnInfo), 0, sizeof(LaneConnInfo));
311 laneConnInfo.laneId = 1;
312 laneConnInfo.type = LANE_WLAN_5G;
313 AuthOnLaneAllocSuccess(laneReqId, &laneConnInfo);
314
315 DupAuthManager(auth);
316 DestroyAuthManagerList();
317 AuthCommonDeinit();
318 DeInitAuthReqInfo();
319 }
320
321 /*
322 * @tc.name: AUTH_ALLOC_LANE_WLAN_002
323 * @tc.desc: AuthDeviceOpenConn return SOFTBUS_AUTH_NOT_FOUND
324 * @tc.type: FUNC
325 * @tc.require:
326 */
327 HWTEST_F(AuthLaneTest, AUTH_ALLOC_LANE_WLAN_002, TestSize.Level1)
328 {
329 AuthLaneInterfaceMock mock;
330 SoftBusLooper loop;
331 EXPECT_CALL(mock, GetLooper).WillRepeatedly(Return(&loop));
332 EXPECT_CALL(mock, LnnGetRemoteStrInfo)
333 .WillRepeatedly(DoAll(SetArrayArgument<2>(UUID_TEST, UUID_TEST + UUID_BUF_LEN), Return(SOFTBUS_OK)));
334 InitAuthReqInfo();
335 ListInit(&g_authClientList);
336 ListInit(&g_authServerList);
337 AuthCommonInit();
338
339 AuthSessionInfo info;
340 SetAuthSessionInfo(&info, CONN_ID, false, AUTH_LINK_TYPE_WIFI);
341 EXPECT_TRUE(NewAuthManager(AUTH_SEQ, &info) != nullptr);
342 AuthConnInfo connInfo;
343 (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
344 connInfo.type = AUTH_LINK_TYPE_WIFI;
345 ASSERT_TRUE(memcpy_s(connInfo.info.ipInfo.ip, IP_LEN, IP_TEST, strlen(IP_TEST)) == EOK);
346 AuthManager *auth = FindAuthManagerByConnInfo(&connInfo, false);
347 EXPECT_TRUE(auth != nullptr);
348 auth->hasAuthPassed[AUTH_LINK_TYPE_WIFI] = true;
349
350 uint32_t authRequestId = AuthGenRequestId();
351 int32_t ret = AuthAllocLane(NETWORK_ID, authRequestId, &authConnCb);
352 EXPECT_NE(ret, SOFTBUS_OK);
353
354 uint32_t laneReqId = GetLaneManager()->lnnGetLaneHandle(LANE_TYPE_CTRL);
355 LaneConnInfo laneConnInfo;
356 (void)memset_s(&laneConnInfo, sizeof(LaneConnInfo), 0, sizeof(LaneConnInfo));
357 laneConnInfo.laneId = 1;
358 laneConnInfo.type = LANE_WLAN_5G;
359 AuthOnLaneAllocSuccess(laneReqId, &laneConnInfo);
360
361 DupAuthManager(auth);
362 DestroyAuthManagerList();
363 AuthCommonDeinit();
364 DeInitAuthReqInfo();
365 }
366
367 /*
368 * @tc.name: AUTH_ALLOC_LANE_WLAN_003
369 * @tc.desc: AuthOnLaneAllocFail
370 * @tc.type: FUNC
371 * @tc.require:
372 */
373 HWTEST_F(AuthLaneTest, AUTH_ALLOC_LANE_WLAN_003, TestSize.Level1)
374 {
375 AuthLaneInterfaceMock mock;
376 SoftBusLooper loop;
377 EXPECT_CALL(mock, GetLooper).WillRepeatedly(Return(&loop));
378 EXPECT_CALL(mock, LnnGetRemoteStrInfo)
379 .WillRepeatedly(DoAll(SetArrayArgument<2>(UUID_TEST, UUID_TEST + UUID_BUF_LEN), Return(SOFTBUS_OK)));
380 InitAuthReqInfo();
381 ListInit(&g_authClientList);
382 ListInit(&g_authServerList);
383 AuthCommonInit();
384
385 AuthSessionInfo info;
386 SetAuthSessionInfo(&info, CONN_ID, false, AUTH_LINK_TYPE_WIFI);
387 EXPECT_TRUE(NewAuthManager(AUTH_SEQ, &info) != nullptr);
388 AuthConnInfo connInfo;
389 (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
390 connInfo.type = AUTH_LINK_TYPE_WIFI;
391 ASSERT_TRUE(memcpy_s(connInfo.info.ipInfo.ip, IP_LEN, IP_TEST, strlen(IP_TEST)) == EOK);
392 AuthManager *auth = FindAuthManagerByConnInfo(&connInfo, false);
393 EXPECT_TRUE(auth != nullptr);
394 auth->hasAuthPassed[AUTH_LINK_TYPE_WIFI] = true;
395
396 uint32_t authRequestId = AuthGenRequestId();
397 int32_t ret = AuthAllocLane(NETWORK_ID, authRequestId, &authConnCb);
398 EXPECT_NE(ret, SOFTBUS_OK);
399
400 uint32_t laneReqId = GetLaneManager()->lnnGetLaneHandle(LANE_TYPE_CTRL);
401 AuthOnLaneAllocFail(laneReqId, SOFTBUS_INVALID_PARAM);
402
403 DupAuthManager(auth);
404 DestroyAuthManagerList();
405 AuthCommonDeinit();
406 DeInitAuthReqInfo();
407 }
408
409 /*
410 * @tc.name: AUTH_ALLOC_LANE_BLE_001
411 * @tc.desc: auth alloc lane ble test
412 * @tc.type: FUNC
413 * @tc.require:
414 */
415 HWTEST_F(AuthLaneTest, AUTH_ALLOC_LANE_BLE_001, TestSize.Level1)
416 {
417 AuthLaneInterfaceMock mock;
418 SoftBusLooper loop;
419 EXPECT_CALL(mock, GetLooper).WillRepeatedly(Return(&loop));
420 EXPECT_CALL(mock, SoftBusGetTime).WillRepeatedly(Return(SOFTBUS_OK));
421 EXPECT_CALL(mock, LnnGetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
422 EXPECT_CALL(mock, LnnGetRemoteStrInfo)
423 .WillRepeatedly(DoAll(SetArrayArgument<2>(UUID_TEST, UUID_TEST + UUID_BUF_LEN), Return(SOFTBUS_OK)));
424 InitAuthReqInfo();
425 ListInit(&g_authClientList);
426 ListInit(&g_authServerList);
427 AuthCommonInit();
428
429 AuthSessionInfo info;
430 SetAuthSessionInfo(&info, CONN_ID, false, AUTH_LINK_TYPE_BLE);
431 EXPECT_TRUE(NewAuthManager(AUTH_SEQ, &info) != nullptr);
432 AuthConnInfo connInfo;
433 (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
434 connInfo.type = AUTH_LINK_TYPE_BLE;
435 ASSERT_TRUE(memcpy_s(connInfo.info.bleInfo.bleMac, BT_MAC_LEN, BLE_MAC, strlen(BLE_MAC)) == EOK);
436 AuthManager *auth = FindAuthManagerByConnInfo(&connInfo, false);
437 EXPECT_TRUE(auth != nullptr);
438 auth->hasAuthPassed[AUTH_LINK_TYPE_BLE] = true;
439 auth->authId = 1;
440 auth->lastVerifyTime = 1;
441
442 uint32_t authRequestId = AuthGenRequestId();
443 int32_t ret = AuthAllocLane(NETWORK_ID, authRequestId, &authConnCb);
444 EXPECT_NE(ret, SOFTBUS_OK);
445
446 uint32_t laneReqId = GetLaneManager()->lnnGetLaneHandle(LANE_TYPE_CTRL);
447 LaneConnInfo laneConnInfo;
448 (void)memset_s(&laneConnInfo, sizeof(LaneConnInfo), 0, sizeof(LaneConnInfo));
449 laneConnInfo.laneId = 1;
450 laneConnInfo.type = LANE_BLE;
451 AuthOnLaneAllocSuccess(laneReqId, &laneConnInfo);
452
453 DupAuthManager(auth);
454 DestroyAuthManagerList();
455 AuthCommonDeinit();
456 DeInitAuthReqInfo();
457 }
458
459 /*
460 * @tc.name: AUTH_ALLOC_LANE_BR_001
461 * @tc.desc: auth alloc lane br test
462 * @tc.type: FUNC
463 * @tc.require:
464 */
465 HWTEST_F(AuthLaneTest, AUTH_ALLOC_LANE_BR_001, TestSize.Level1)
466 {
467 AuthLaneInterfaceMock mock;
468 SoftBusLooper loop;
469 EXPECT_CALL(mock, GetLooper).WillRepeatedly(Return(&loop));
470 EXPECT_CALL(mock, SoftBusGetTime).WillRepeatedly(Return(SOFTBUS_OK));
471 EXPECT_CALL(mock, LnnGetRemoteStrInfo)
472 .WillRepeatedly(DoAll(SetArrayArgument<2>(UUID_TEST, UUID_TEST + UUID_BUF_LEN), Return(SOFTBUS_OK)));
473 InitAuthReqInfo();
474 ListInit(&g_authClientList);
475 ListInit(&g_authServerList);
476 AuthCommonInit();
477
478 AuthSessionInfo info;
479 SetAuthSessionInfo(&info, CONN_ID, false, AUTH_LINK_TYPE_BR);
480 EXPECT_TRUE(NewAuthManager(AUTH_SEQ, &info) != nullptr);
481 AuthConnInfo connInfo;
482 (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
483 connInfo.type = AUTH_LINK_TYPE_BR;
484 ASSERT_TRUE(memcpy_s(connInfo.info.brInfo.brMac, BT_MAC_LEN, BR_MAC, strlen(BR_MAC)) == EOK);
485 AuthManager *auth = FindAuthManagerByConnInfo(&connInfo, false);
486 EXPECT_TRUE(auth != nullptr);
487 auth->hasAuthPassed[AUTH_LINK_TYPE_BR] = true;
488 auth->authId = 1;
489 auth->lastVerifyTime = 1;
490
491 uint32_t authRequestId = AuthGenRequestId();
492 int32_t ret = AuthAllocLane(NETWORK_ID, authRequestId, &authConnCb);
493 EXPECT_NE(ret, SOFTBUS_OK);
494
495 uint32_t laneReqId = GetLaneManager()->lnnGetLaneHandle(LANE_TYPE_CTRL);
496 LaneConnInfo laneConnInfo;
497 (void)memset_s(&laneConnInfo, sizeof(LaneConnInfo), 0, sizeof(LaneConnInfo));
498 laneConnInfo.laneId = 1;
499 laneConnInfo.type = LANE_BR;
500 AuthOnLaneAllocSuccess(laneReqId, &laneConnInfo);
501
502 DupAuthManager(auth);
503 DestroyAuthManagerList();
504 AuthCommonDeinit();
505 DeInitAuthReqInfo();
506 }
507
508 /*
509 * @tc.name: AUTH_ALLOC_LANE_P2P_001
510 * @tc.desc: IsReuseP2p return false
511 * @tc.type: FUNC
512 * @tc.require:
513 */
514 HWTEST_F(AuthLaneTest, AUTH_ALLOC_LANE_P2P_001, TestSize.Level1)
515 {
516 AuthLaneInterfaceMock mock;
517 SoftBusLooper loop;
518 EXPECT_CALL(mock, GetLooper).WillRepeatedly(Return(&loop));
519 EXPECT_CALL(mock, LnnGetRemoteStrInfo)
520 .WillRepeatedly(DoAll(SetArrayArgument<2>(UUID_TEST, UUID_TEST + UUID_BUF_LEN), Return(SOFTBUS_OK)));
521 InitAuthReqInfo();
522 ListInit(&g_authClientList);
523 ListInit(&g_authServerList);
524 AuthCommonInit();
525
526 AuthSessionInfo info;
527 SetAuthSessionInfo(&info, CONN_ID, false, AUTH_LINK_TYPE_P2P);
528 EXPECT_TRUE(NewAuthManager(AUTH_SEQ, &info) != nullptr);
529 AuthConnInfo connInfo;
530 (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
531 connInfo.type = AUTH_LINK_TYPE_P2P;
532 ASSERT_TRUE(memcpy_s(connInfo.info.ipInfo.ip, IP_LEN, IP_TEST, strlen(IP_TEST)) == EOK);
533 connInfo.info.ipInfo.port = PORT;
534 AuthManager *auth = FindAuthManagerByConnInfo(&connInfo, false);
535 EXPECT_TRUE(auth != nullptr);
536 auth->hasAuthPassed[AUTH_LINK_TYPE_P2P] = true;
537 auth->authId = 1;
538 auth->lastVerifyTime = 1;
539
540 uint32_t authRequestId = AuthGenRequestId();
541 int32_t ret = AuthAllocLane(NETWORK_ID, authRequestId, &authConnCb);
542 EXPECT_NE(ret, SOFTBUS_OK);
543
544 uint32_t laneReqId = GetLaneManager()->lnnGetLaneHandle(LANE_TYPE_CTRL);
545 AuthOnLaneAllocFail(laneReqId, SOFTBUS_INVALID_PARAM);
546
547 DupAuthManager(auth);
548 DestroyAuthManagerList();
549 AuthCommonDeinit();
550 DeInitAuthReqInfo();
551 }
552
553 /*
554 * @tc.name: AUTH_ALLOC_LANE_ENHANCED_P2P_001
555 * @tc.desc: IsReuseP2p return false
556 * @tc.type: FUNC
557 * @tc.require:
558 */
559 HWTEST_F(AuthLaneTest, AUTH_ALLOC_LANE_ENHANCED_P2P_001, TestSize.Level1)
560 {
561 AuthLaneInterfaceMock mock;
562 SoftBusLooper loop;
563 EXPECT_CALL(mock, GetLooper).WillRepeatedly(Return(&loop));
564 EXPECT_CALL(mock, LnnGetRemoteStrInfo)
565 .WillRepeatedly(DoAll(SetArrayArgument<2>(UUID_TEST, UUID_TEST + UUID_BUF_LEN), Return(SOFTBUS_OK)));
566 InitAuthReqInfo();
567 ListInit(&g_authClientList);
568 ListInit(&g_authServerList);
569 AuthCommonInit();
570
571 AuthSessionInfo info;
572 SetAuthSessionInfo(&info, CONN_ID, false, AUTH_LINK_TYPE_ENHANCED_P2P);
573 EXPECT_TRUE(NewAuthManager(AUTH_SEQ, &info) != nullptr);
574 AuthConnInfo connInfo;
575 (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
576 connInfo.type = AUTH_LINK_TYPE_ENHANCED_P2P;
577 ASSERT_TRUE(memcpy_s(connInfo.info.ipInfo.ip, IP_LEN, IP_TEST, strlen(IP_TEST)) == EOK);
578 connInfo.info.ipInfo.port = PORT;
579 AuthManager *auth = FindAuthManagerByConnInfo(&connInfo, false);
580 EXPECT_TRUE(auth != nullptr);
581 auth->hasAuthPassed[AUTH_LINK_TYPE_ENHANCED_P2P] = true;
582 auth->authId = 1;
583 auth->lastVerifyTime = 1;
584
585 uint32_t authRequestId = AuthGenRequestId();
586 int32_t ret = AuthAllocLane(NETWORK_ID, authRequestId, &authConnCb);
587 EXPECT_NE(ret, SOFTBUS_OK);
588
589 uint32_t laneReqId = GetLaneManager()->lnnGetLaneHandle(LANE_TYPE_CTRL);
590 AuthOnLaneAllocFail(laneReqId, SOFTBUS_INVALID_PARAM);
591
592 DelAuthManager(auth, connInfo.type);
593 DestroyAuthManagerList();
594 AuthCommonDeinit();
595 DeInitAuthReqInfo();
596 }
597 } // namespace OHOS