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 <cinttypes>
17 #include <gtest/gtest.h>
18 #include <securec.h>
19 #include <sys/time.h>
20 
21 #include "auth_connection.h"
22 #include "auth_connection.c"
23 #include "auth_device.c"
24 #include "auth_interface.h"
25 #include "auth_interface.c"
26 #include "auth_lane.c"
27 #include "auth_log.h"
28 #include "auth_manager.h"
29 #include "auth_manager.c"
30 #include "auth_session_fsm.h"
31 #include "auth_session_fsm.c"
32 #include "auth_session_key.h"
33 #include "auth_session_key.c"
34 #include "softbus_errcode.h"
35 #include "softbus_adapter_json.h"
36 #include "softbus_socket.h"
37 #include "lnn_ctrl_lane.h"
38 #include "lnn_lane_score.h"
39 #include "lnn_lane_interface.h"
40 
41 namespace OHOS {
42 using namespace testing::ext;
43 using namespace testing;
44 constexpr uint32_t TEST_DATA_LEN = 30;
45 constexpr uint32_t MSG_LEN = 50;
46 constexpr char NETWORK_ID[] = "testnetworkid123";
47 
48 class AuthOtherTest : public testing::Test {
49 public:
50     static void SetUpTestCase();
51     static void TearDownTestCase();
52     void SetUp();
53     void TearDown();
54 };
55 
SetUpTestCase()56 void AuthOtherTest::SetUpTestCase()
57 {
58     int32_t ret =  AuthCommonInit();
59     EXPECT_TRUE(ret == SOFTBUS_OK);
60 }
61 
TearDownTestCase()62 void AuthOtherTest::TearDownTestCase()
63 {
64     AuthCommonDeinit();
65 }
66 
SetUp()67 void AuthOtherTest::SetUp()
68 {
69 }
70 
TearDown()71 void AuthOtherTest::TearDown() {}
72 
OnConnectResultTest(uint32_t requestId,uint64_t connId,int32_t result,const AuthConnInfo * connInfo)73 void OnConnectResultTest(uint32_t requestId, uint64_t connId, int32_t result, const AuthConnInfo *connInfo)
74 {
75     (void)requestId;
76     (void)connId;
77     (void)result;
78     (void)connInfo;
79 }
80 
OnDisconnectedTest(uint64_t connId,const AuthConnInfo * connInfo)81 void OnDisconnectedTest(uint64_t connId, const AuthConnInfo *connInfo)
82 {
83     (void)connId;
84     (void)connInfo;
85 }
86 
OnDataReceivedTest(uint64_t connId,const AuthConnInfo * connInfo,bool fromServer,const AuthDataHead * head,const uint8_t * data)87 void OnDataReceivedTest(uint64_t connId, const AuthConnInfo *connInfo, bool fromServer,
88     const AuthDataHead *head, const uint8_t *data)
89 {
90     (void)connId;
91     (void)connInfo;
92     (void)fromServer;
93     (void)head;
94     (void)data;
95 }
96 
OnDeviceNotTrustedTest(const char * udid)97 void OnDeviceNotTrustedTest(const char *udid)
98 {
99     (void)udid;
100 }
101 
OnDeviceVerifyPassTest(AuthHandle authHandle,const NodeInfo * info)102 void OnDeviceVerifyPassTest(AuthHandle authHandle, const NodeInfo *info)
103 {
104     (void)authHandle;
105     (void)info;
106 }
107 
OnDeviceDisconnectTest(int64_t authId)108 void OnDeviceDisconnectTest(int64_t authId)
109 {
110     (void)authId;
111 }
112 
OnGroupCreatedTest(const char * groupId,int32_t groupType)113 void OnGroupCreatedTest(const char *groupId, int32_t groupType)
114 {
115     (void)groupId;
116     (void)groupType;
117 }
118 
OnGroupDeletedTest(const char * groupId)119 void OnGroupDeletedTest(const char *groupId)
120 {
121     (void)groupId;
122 }
123 
124 /*
125  * @tc.name: ADD_CONN_REQUEST_TEST_001
126  * @tc.desc: add conn request test
127  * @tc.type: FUNC
128  * @tc.require:
129  */
130 HWTEST_F(AuthOtherTest, ADD_CONN_REQUEST_TEST_001, TestSize.Level1)
131 {
132     AuthConnInfo connInfo;
133     uint32_t requestId = 0;
134     int32_t fd = 0;
135 
136     int32_t ret = AddConnRequest(&connInfo, requestId, fd);
137     EXPECT_TRUE(ret == SOFTBUS_OK);
138     ConnRequest *item = FindConnRequestByRequestId(requestId);
139     EXPECT_TRUE(item != nullptr);
140     DelConnRequest(nullptr);
141     DelConnRequest(item);
142 }
143 
144 /*
145  * @tc.name: REMOVE_FUNC_TEST_001
146  * @tc.desc: remove func test
147  * @tc.type: FUNC
148  * @tc.require:
149  */
150 HWTEST_F(AuthOtherTest, REMOVE_FUNC_TEST_001, TestSize.Level1)
151 {
152     uint32_t obj = 1;
153     uint32_t param = 1;
154 
155     int32_t ret = RemoveFunc(nullptr, static_cast<void *>(&param));
156     EXPECT_TRUE(ret == SOFTBUS_ERR);
157     ret = RemoveFunc(static_cast<void *>(&obj), nullptr);
158     EXPECT_TRUE(ret == SOFTBUS_ERR);
159     ret = RemoveFunc(static_cast<void *>(&obj), static_cast<void *>(&param));
160     EXPECT_TRUE(ret == SOFTBUS_OK);
161 }
162 
163 /*
164  * @tc.name: CHECK_ACTIVE_AUTH_CONNECTION_TEST_001
165  * @tc.desc: check active auth connection test
166  * @tc.type: FUNC
167  * @tc.require:
168  */
169 HWTEST_F(AuthOtherTest, CHECK_ACTIVE_AUTH_CONNECTION_TEST_001, TestSize.Level1)
170 {
171     AuthConnInfo connInfo;
172 
173     (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
174     bool ret = CheckActiveAuthConnection(nullptr);
175     EXPECT_TRUE(ret == false);
176     ret = CheckActiveAuthConnection(&connInfo);
177     EXPECT_TRUE(ret == false);
178 }
179 
180 /*
181  * @tc.name: AUTH_GET_META_TYPE_TEST_001
182  * @tc.desc: auth get meta type test
183  * @tc.type: FUNC
184  * @tc.require:
185  */
186 HWTEST_F(AuthOtherTest, AUTH_GET_META_TYPE_TEST_001, TestSize.Level1)
187 {
188     int64_t authId = 0;
189     bool isMetaAuth = false;
190 
191     int32_t ret = AuthGetMetaType(authId, nullptr);
192     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
193     ret = AuthGetMetaType(authId, &isMetaAuth);
194     EXPECT_TRUE(ret == SOFTBUS_OK);
195 }
196 
197 /*
198  * @tc.name: REMOVE_AUTH_MANAGER_BY_AUTH_ID_TEST_001
199  * @tc.desc: remove auth manager by auth id test
200  * @tc.type: FUNC
201  * @tc.require:
202  */
203 HWTEST_F(AuthOtherTest, REMOVE_AUTH_MANAGER_BY_AUTH_ID_TEST_001, TestSize.Level1)
204 {
205     int64_t authSeq = 0;
206     AuthSessionInfo info;
207     AuthConnInfo connInfo;
208     const char *udid = "000";
209     uint64_t connId = 0;
210     uint64_t errConnId = 1;
211     const char *ip = "192.168.12.1";
212 
213     (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
214     (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
215     (void)strcpy_s(info.udid, UDID_BUF_LEN, udid);
216     (void)strcpy_s(info.uuid, UUID_BUF_LEN, udid);
217     info.connId = 0;
218     info.isServer = true;
219     info.connInfo.type = AUTH_LINK_TYPE_WIFI;
220     ListInit(&g_authServerList);
221     (void)strcpy_s(info.connInfo.info.ipInfo.ip, IP_LEN, ip);
222     AuthManager *auth = NewAuthManager(authSeq, &info);
223     EXPECT_TRUE(auth != nullptr);
224     int64_t ret = GetAuthIdByConnId(errConnId, true);
225     EXPECT_TRUE(ret == AUTH_INVALID_ID);
226     ret = GetAuthIdByConnId(connId, true);
227     EXPECT_TRUE(ret != AUTH_INVALID_ID);
228     connInfo.type = AUTH_LINK_TYPE_WIFI;
229     (void)strcpy_s(connInfo.info.ipInfo.ip, IP_LEN, ip);
230     ret = GetActiveAuthIdByConnInfo(&connInfo, false);
231     EXPECT_TRUE(ret == AUTH_INVALID_ID);
232     AuthHandle authHandle = { .authId = authSeq, .type = AUTH_LINK_TYPE_WIFI };
233     RemoveAuthManagerByAuthId(authHandle);
234     RemoveAuthManagerByConnInfo(&connInfo, true);
235     RemoveNotPassedAuthManagerByUdid(udid);
236 }
237 
238 /*
239  * @tc.name: NOTIFY_DEVICE_VERIFY_PASSED_TEST_001
240  * @tc.desc: notify device verify passed test
241  * @tc.type: FUNC
242  * @tc.require:
243  */
244 HWTEST_F(AuthOtherTest, NOTIFY_DEVICE_VERIFY_PASSED_TEST_001, TestSize.Level1)
245 {
246     int64_t authId = 0;
247     int64_t errAuthId = 1;
248     NodeInfo nodeInfo;
249     AuthSessionInfo info;
250 
251     (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
252     (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
253     info.isServer = true;
254     info.connInfo.type = AUTH_LINK_TYPE_BLE;
255     AuthManager *auth = NewAuthManager(authId, &info);
256     EXPECT_TRUE(auth != nullptr);
257     AuthHandle errHandle = { .authId = errAuthId, .type = AUTH_LINK_TYPE_BLE };
258     AuthHandle authHandle = { .authId = authId, .type = AUTH_LINK_TYPE_BLE };
259     AuthNotifyDeviceVerifyPassed(errHandle, &nodeInfo);
260     g_verifyListener.onDeviceVerifyPass = nullptr;
261     AuthNotifyDeviceVerifyPassed(authHandle, &nodeInfo);
262     g_verifyListener.onDeviceVerifyPass = OnDeviceVerifyPassTest,
263     AuthNotifyDeviceVerifyPassed(authHandle, &nodeInfo);
264     DelAuthManager(auth, AUTH_LINK_TYPE_MAX);
265 }
266 
267 /*
268  * @tc.name: AUTH_MANAGER_SET_AUTH_PASSED_TEST_001
269  * @tc.desc: auth manager set auth passed test
270  * @tc.type: FUNC
271  * @tc.require:
272  */
273 HWTEST_F(AuthOtherTest, AUTH_MANAGER_SET_AUTH_PASSED_TEST_001, TestSize.Level1)
274 {
275     int64_t authSeq = 0;
276     int64_t errAuthId = 1;
277     AuthSessionInfo info;
278     int32_t reason = 0;
279 
280     (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
281     info.connInfo.type = AUTH_LINK_TYPE_WIFI;
282     AuthManager *auth = NewAuthManager(authSeq, &info);
283     EXPECT_TRUE(auth != nullptr);
284     AuthManagerSetAuthPassed(authSeq, nullptr);
285     AuthManagerSetAuthPassed(errAuthId, &info);
286     AuthManagerSetAuthPassed(authSeq, &info);
287     AuthManagerSetAuthFailed(errAuthId, &info, reason);
288     AuthManagerSetAuthFailed(authSeq, &info, reason);
289     DelAuthManager(auth, AUTH_LINK_TYPE_MAX);
290 }
291 
292 /*
293  * @tc.name: HANDLE_CONNECTION_DATA_TEST_001
294  * @tc.desc: handle connection data test
295  * @tc.type: FUNC
296  * @tc.require:
297  */
298 HWTEST_F(AuthOtherTest, HANDLE_CONNECTION_DATA_TEST_001, TestSize.Level1)
299 {
300     uint64_t connId = 0;
301     int64_t authId = 0;
302     AuthConnInfo connInfo;
303     AuthDataHead head;
304     AuthSessionInfo info;
305     const uint8_t *data = nullptr;
306     bool fromServer = true;
307     const char *ip = "192.168.12.1";
308 
309     (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
310     (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
311     (void)memset_s(&head, sizeof(AuthDataHead), 0, sizeof(AuthDataHead));
312     info.connInfo.type = AUTH_LINK_TYPE_WIFI;
313     (void)strcpy_s(info.connInfo.info.ipInfo.ip, IP_LEN, ip);
314     AuthManager *auth = NewAuthManager(authId, &info);
315     EXPECT_TRUE(auth != nullptr);
316     HandleConnectionData(connId, &connInfo, fromServer, &head, data);
317     connInfo.type = AUTH_LINK_TYPE_WIFI;
318     (void)strcpy_s(connInfo.info.ipInfo.ip, IP_LEN, ip);
319     HandleConnectionData(connId, &connInfo, fromServer, &head, data);
320     DelAuthManager(auth, AUTH_LINK_TYPE_MAX);
321 }
322 
323 
OnConnOpenedTest(uint32_t requestId,AuthHandle authHandle)324 static void OnConnOpenedTest(uint32_t requestId, AuthHandle authHandle)
325 {
326     AUTH_LOGI(AUTH_TEST, "OnConnOpenedTest: requestId=%{public}d, authId=%{public}" PRId64 ".",
327         requestId, authHandle.authId);
328 }
329 
OnConnOpenFailedTest(uint32_t requestId,int32_t reason)330 static void OnConnOpenFailedTest(uint32_t requestId, int32_t reason)
331 {
332     AUTH_LOGI(AUTH_TEST, "OnConnOpenFailedTest: requestId=%{public}d, reason=%{public}d.", requestId, reason);
333 }
334 
335 /*
336  * @tc.name: AUTH_DEVICE_OPEN_CONN_TEST_001
337  * @tc.desc: auth device open conn test
338  * @tc.type: FUNC
339  * @tc.require:
340  */
341 HWTEST_F(AuthOtherTest, AUTH_DEVICE_OPEN_CONN_TEST_001, TestSize.Level1)
342 {
343     AuthSessionInfo info;
344     AuthConnInfo connInfo;
345     uint32_t requestId = 0;
346     int64_t authId = 0;
347     const char *ip = "192.168.12.1";
348     AuthConnCallback cb = {
349         .onConnOpened = OnConnOpenedTest,
350         .onConnOpenFailed = OnConnOpenFailedTest,
351     };
352 
353     (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
354     (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
355     info.connInfo.type = AUTH_LINK_TYPE_WIFI;
356     (void)strcpy_s(info.connInfo.info.ipInfo.ip, IP_LEN, ip);
357     AuthManager *auth = NewAuthManager(authId, &info);
358     EXPECT_TRUE(auth != nullptr);
359     connInfo.type = AUTH_LINK_TYPE_WIFI;
360     int32_t ret = AuthDeviceOpenConn(&connInfo, requestId, &cb);
361     EXPECT_TRUE(ret == SOFTBUS_AUTH_NOT_FOUND);
362     (void)strcpy_s(connInfo.info.ipInfo.ip, IP_LEN, ip);
363     ret = AuthDeviceOpenConn(&connInfo, requestId, &cb);
364     EXPECT_TRUE(ret == SOFTBUS_AUTH_NOT_FOUND);
365     connInfo.type = AUTH_LINK_TYPE_BR;
366     ret = AuthDeviceOpenConn(&connInfo, requestId, &cb);
367     EXPECT_TRUE(ret != SOFTBUS_OK);
368 }
369 
370 /*
371  * @tc.name: UPDATE_AUTH_REQUEST_CONN_INFO_TEST_001
372  * @tc.desc: update auth request conn info test
373  * @tc.type: FUNC
374  * @tc.require:
375  */
376 HWTEST_F(AuthOtherTest, FIND_AUTH_REQUEST_BY_CONN_INFO_TEST_001, TestSize.Level1)
377 {
378     AuthConnInfo connInfo;
379     AuthRequest request;
380 
381     (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
382     (void)memset_s(&request, sizeof(AuthRequest), 0, sizeof(AuthRequest));
383     int32_t ret = FindAuthRequestByConnInfo(&connInfo, &request);
384     EXPECT_TRUE(ret == SOFTBUS_NOT_FIND);
385     uint32_t requestId = 1;
386     ret = GetAuthRequestNoLock(requestId, &request);
387     EXPECT_TRUE(ret == SOFTBUS_NOT_FIND);
388     ret = FindAndDelAuthRequestByConnInfo(requestId, &connInfo);
389     EXPECT_TRUE(ret == SOFTBUS_NOT_FIND);
390     int32_t result = 1;
391     int64_t authId = 10;
392     PerformAuthConnCallback(requestId, result, authId);
393     AuthConnCallback cb = {
394         .onConnOpened = OnConnOpenedTest,
395         .onConnOpenFailed = OnConnOpenFailedTest,
396     };
397     request.requestId = 1;
398     request.connInfo.type = AUTH_LINK_TYPE_BLE;
399     request.connCb = cb;
400     ret = AddAuthRequest(&request);
401     EXPECT_TRUE(ret != 0);
402     ret = FindAndDelAuthRequestByConnInfo(requestId, &connInfo);
403     EXPECT_TRUE(ret == SOFTBUS_NOT_FIND);
404     PerformAuthConnCallback(request.requestId, SOFTBUS_OK, authId);
405     PerformAuthConnCallback(request.requestId, SOFTBUS_NOT_FIND, authId);
406     request.connInfo.type = AUTH_LINK_TYPE_WIFI;
407     ret = AddAuthRequest(&request);
408     EXPECT_TRUE(ret != 0);
409     DelAuthRequest(request.requestId);
410 }
411 
412 /*
413  * @tc.name: UPDATE_AUTH_REQUEST_CONN_INFO_TEST_002
414  * @tc.desc: update auth request conn info test
415  * @tc.type: FUNC
416  * @tc.require:
417  */
418 HWTEST_F(AuthOtherTest, FIND_AUTH_REQUEST_BY_CONN_INFO_TEST_002, TestSize.Level1)
419 {
420     AuthConnInfo connInfo;
421     AuthRequest request;
422     int64_t authId = 10;
423     uint32_t requestId = 1;
424     AuthConnCallback connCb = {
425         .onConnOpened = nullptr,
426         .onConnOpenFailed = nullptr,
427     };
428 
429     (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
430     (void)memset_s(&request, sizeof(AuthRequest), 0, sizeof(AuthRequest));
431     request.requestId = requestId;
432     request.connInfo.type = AUTH_LINK_TYPE_BLE;
433     request.connCb = connCb;
434     int32_t ret = AddAuthRequest(&request);
435     EXPECT_TRUE(ret != 0);
436     PerformAuthConnCallback(requestId, SOFTBUS_OK, authId);
437     connInfo.type = AUTH_LINK_TYPE_BLE;
438     request.requestId = 2;
439     ret = FindAndDelAuthRequestByConnInfo(request.requestId, &connInfo);
440     EXPECT_TRUE(ret == SOFTBUS_NOT_FIND);
441     ret = AddAuthRequest(&request);
442     EXPECT_TRUE(ret != 0);
443     DelAuthRequest(requestId);
444     DelAuthRequest(request.requestId);
445 }
446 
447 /*
448  * @tc.name: RMOVE_UPDATE_SESSION_KEY_FUNC_TEST_001
449  * @tc.desc: rmove update session key func test
450  * @tc.type: FUNC
451  * @tc.require:
452  */
453 HWTEST_F(AuthOtherTest, RMOVE_UPDATE_SESSION_KEY_FUNC_TEST_001, TestSize.Level1)
454 {
455     int64_t authId = 1;
456     int64_t para = 0;
457     int32_t ret = RemoveUpdateSessionKeyFunc(nullptr, nullptr);
458     EXPECT_TRUE(ret == SOFTBUS_ERR);
459     ret = RemoveUpdateSessionKeyFunc(&authId, nullptr);
460     EXPECT_TRUE(ret == SOFTBUS_ERR);
461     ret = RemoveUpdateSessionKeyFunc(&authId, &para);
462     EXPECT_TRUE(ret == SOFTBUS_ERR);
463     ret = RemoveUpdateSessionKeyFunc(&authId, &authId);
464     EXPECT_TRUE(ret == SOFTBUS_OK);
465 }
466 
467 /*
468  * @tc.name: POST_CLOSE_ACK_MESSAGE_TEST_001
469  * @tc.desc: post close ack message test
470  * @tc.type: FUNC
471  * @tc.require:
472  */
473 HWTEST_F(AuthOtherTest, POST_CLOSE_ACK_MESSAGE_TEST_001, TestSize.Level1)
474 {
475     int64_t authSeq = 0;
476     AuthSessionInfo info;
477     (void)memset_s(&info, sizeof(info), 0, sizeof(info));
478     int32_t ret = PostCloseAckMessage(authSeq, nullptr);
479     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
480     ret = PostCloseAckMessage(authSeq, &info);
481     EXPECT_TRUE(ret != SOFTBUS_OK);
482 }
483 
484 /*
485  * @tc.name: PACK_AUTH_DATA_TEST_001
486  * @tc.desc: pack auth data test
487  * @tc.type: FUNC
488  * @tc.require:
489  */
490 HWTEST_F(AuthOtherTest, PACK_AUTH_DATA_TEST_001, TestSize.Level1)
491 {
492     AuthDataHead head;
493     uint8_t *buf = NULL;
494     const uint8_t data[TEST_DATA_LEN] = { 0 };
495     uint32_t len = 32;
496 
497     (void)memset_s(&head, sizeof(AuthDataHead), AUTH_CONN_DATA_HEAD_SIZE, sizeof(AuthDataHead));
498     int32_t ret = PackAuthData(&head, data, buf, len);
499     EXPECT_TRUE(ret == SOFTBUS_NO_ENOUGH_DATA);
500 }
501 
502 /*
503  * @tc.name: ON_COMM_DATA_RECEIVED_TEST_001
504  * @tc.desc: on commdata received test
505  * @tc.type: FUNC
506  * @tc.require:
507  */
508 HWTEST_F(AuthOtherTest, ON_COMM_DATA_RECEIVED_TEST_001, TestSize.Level1)
509 {
510     uint32_t connectionId = 0;
511     ConnModule moduleId = MODULE_DEVICE_AUTH;
512     int64_t seq = 0;
513     char *data = reinterpret_cast<char *>(malloc(1024));
514     const int SEND_DATA_SIZE_1KB = 1024;
515     ASSERT_NE(data, nullptr);
516     const char *testData = "{\"data\":\"open session test!!!\"}";
517     int32_t len = 2;
518     int32_t ret = memcpy_s(data, SEND_DATA_SIZE_1KB, testData, strlen(testData));
519     EXPECT_EQ(ret, SOFTBUS_OK);
520 
521     OnCommDataReceived(connectionId, moduleId, seq, NULL, len);
522     OnCommDataReceived(connectionId, moduleId, seq, data, len);
523     free(data);
524 }
525 
526 /*
527  * @tc.name: GET_CONN_SIDE_TYPE_TEST_001
528  * @tc.desc: get connside type test
529  * @tc.type: FUNC
530  * @tc.require:
531  */
532 HWTEST_F(AuthOtherTest, GET_CONN_SIDE_TYPE_TEST_001, TestSize.Level1)
533 {
534     uint64_t connId = 0;
535     connId = GetConnType(connId);
536     ConnSideType ret = GetConnSideType(connId);
537     EXPECT_EQ(ret, CONN_SIDE_ANY);
538     ret = GetConnSideType(0x1FFFFFFFF);
539     EXPECT_EQ(ret, CONN_SIDE_ANY);
540     ret = GetConnSideType(0x2FFFFFFFF);
541     EXPECT_EQ(ret, CONN_SIDE_ANY);
542     ret = GetConnSideType(0x3FFFFFFFF);
543     EXPECT_EQ(ret, CONN_SIDE_ANY);
544     ret = GetConnSideType(0x4FFFFFFFF);
545     EXPECT_EQ(ret, CONN_SIDE_ANY);
546 }
547 
548 /*
549  * @tc.name: ON_COMM_DATA_RECEVIED_TEST_001
550  * @tc.desc: on comm data received test
551  * @tc.type: FUNC
552  * @tc.require:
553  */
554 HWTEST_F(AuthOtherTest, ON_COMM_DATA_RECEVIED_TEST_001, TestSize.Level1)
555 {
556     uint32_t connectionId = 0;
557     ConnModule moduleId = MODULE_DEVICE_AUTH;
558     int64_t seq = 0;
559     int32_t len = 0;
560     char *data = reinterpret_cast<char *>(malloc(1024));
561     ASSERT_NE(data, nullptr);
562     OnCommDataReceived(connectionId, moduleId, seq, data, len);
563 
564     const int SEND_DATA_SIZE_1KB = 1024;
565     const char *testData = "{\"data\":\"open session test!!!\"}";
566     len = 2;
567     moduleId = MODULE_CONNECTION;
568     int32_t ret = memcpy_s(data, SEND_DATA_SIZE_1KB, testData, strlen(testData));
569     EXPECT_EQ(ret, SOFTBUS_OK);
570     OnCommDataReceived(connectionId, moduleId, seq, data, len);
571 
572     free(data);
573 }
574 
575 /*
576  * @tc.name: IS_FLUSH_DEVICE_PACKET_TEST_001
577  * @tc.desc: is flush device packet test
578  * @tc.type: FUNC
579  * @tc.require:
580  */
581 HWTEST_F(AuthOtherTest, IS_FLUSH_DEVICE_PACKET_TEST_001, TestSize.Level1)
582 {
583     const char *sessionKeyStr = "www.test.com";
584     AuthConnInfo *connInfo = (AuthConnInfo*)SoftBusCalloc(sizeof(AuthConnInfo));
585     if (connInfo == NULL) {
586         return;
587     }
588     (void)memset_s(connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
589     connInfo->type = AUTH_LINK_TYPE_BLE;
590 
591     AuthDataHead *head = (AuthDataHead*)SoftBusCalloc(sizeof(AuthDataHead));
592     if (head == NULL) {
593         return;
594     }
595     (void)memset_s(head, sizeof(AuthDataHead), 0, sizeof(AuthDataHead));
596     head->len = strlen(sessionKeyStr);
597     const uint8_t data = {0};
598     bool isServer = false;
599     DeviceMessageParse messageParse = { 0 };
600     bool ret = IsDeviceMessagePacket(connInfo, head, &data, isServer, &messageParse);
601     EXPECT_TRUE(ret == false);
602     connInfo->type = AUTH_LINK_TYPE_WIFI;
603     ret = IsDeviceMessagePacket(connInfo, head, &data, isServer, &messageParse);
604     EXPECT_TRUE(ret == false);
605     SoftBusFree(head);
606     SoftBusFree(connInfo);
607 }
608 
609 /*
610  * @tc.name: FSM_MSG_TYPE_TO_STR_TEST_001
611  * @tc.desc: fsm msg type to str test
612  * @tc.type: FUNC
613  * @tc.require:
614  */
615 HWTEST_F(AuthOtherTest, FSM_MSG_TYPE_TO_STR_TEST_001, TestSize.Level1)
616 {
617     int32_t type = FSM_MSG_UNKNOWN;
618     const char *str = "UNKNOWN MSG!!";
619     char *ret = FsmMsgTypeToStr(type);
620     EXPECT_EQ(ret, str);
621     type = -1;
622     ret = FsmMsgTypeToStr(type);
623     EXPECT_EQ(ret, str);
624     type = FSM_MSG_RECV_DEVICE_ID;
625     ret = FsmMsgTypeToStr(type);
626     const char *str1 = "RECV_DEVICE_ID";
627     EXPECT_EQ(ret, str1);
628 }
629 
630 /*
631  * @tc.name: AUTH_MANAGER_SET_SESSION_KEY_TEST_001
632  * @tc.desc: fsm msg type to str test
633  * @tc.type: FUNC
634  * @tc.require:
635  */
636 HWTEST_F(AuthOtherTest, AUTH_MANAGER_SET_SESSION_KEY_TEST_001, TestSize.Level1)
637 {
638     int64_t authSeq = 0;
639     AuthSessionInfo *info = (AuthSessionInfo*)SoftBusCalloc(sizeof(AuthSessionInfo));
640     if (info == NULL) {
641         return;
642     }
643     info->requestId = 1;
644     info->isServer = false;
645     info->connInfo.type = AUTH_LINK_TYPE_WIFI;
646     SessionKey *sessionKey = (SessionKey*)SoftBusCalloc(sizeof(SessionKey));
647     if (sessionKey == NULL) {
648         return;
649     }
650     sessionKey->len = 0;
651     int32_t ret = AuthManagerSetSessionKey(authSeq, info, sessionKey, false, false);
652     EXPECT_TRUE(ret == SOFTBUS_OK);
653     ret = AuthManagerGetSessionKey(authSeq, info, sessionKey);
654     EXPECT_TRUE(ret != SOFTBUS_OK);
655     AuthManagerSetAuthPassed(authSeq, info);
656     AuthManagerSetAuthFinished(authSeq, info);
657     info->isServer = true;
658     info->connInfo.type = AUTH_LINK_TYPE_BLE;
659     AuthManagerSetAuthFinished(authSeq, info);
660     SoftBusFree(sessionKey);
661     SoftBusFree(info);
662 }
663 
664 /*
665  * @tc.name: AUTH_DEVICE_CLOSE_CONN_TEST_001
666  * @tc.desc: fsm msg type to str test
667  * @tc.type: FUNC
668  * @tc.require:
669  */
670 HWTEST_F(AuthOtherTest, AUTH_DEVICE_CLOSE_CONN_TEST_001, TestSize.Level1)
671 {
672     AuthHandle authHandle = { .authId = 111, .type = AUTH_LINK_TYPE_WIFI };
673     AuthDeviceCloseConn(authHandle);
674     AuthTransData *dataInfo = (AuthTransData*)SoftBusCalloc(sizeof(AuthTransData));
675     if (dataInfo == NULL) {
676         return;
677     }
678     int32_t ret = AuthDevicePostTransData(authHandle, NULL);
679     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
680     dataInfo->module = 1;
681     dataInfo->seq = 2;
682     dataInfo->flag = 0;
683     ret = AuthDevicePostTransData(authHandle, dataInfo);
684     EXPECT_TRUE(ret == SOFTBUS_AUTH_NOT_FOUND);
685     SoftBusFree(dataInfo);
686 }
687 
688 /*
689  * @tc.name: AUTH_DEVICE_GET_PREFER_CONN_INFO_TEST_001
690  * @tc.desc: fsm msg type to str test
691  * @tc.type: FUNC
692  * @tc.require:
693  */
694 HWTEST_F(AuthOtherTest, AUTH_DEVICE_GET_PREFER_CONN_INFO_TEST_001, TestSize.Level1)
695 {
696     const char *uuid = "";
697     int32_t ret = AuthDeviceGetPreferConnInfo(uuid, NULL);
698     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
699     AuthConnInfo *connInfo =(AuthConnInfo*)SoftBusCalloc(sizeof(AuthConnInfo));
700     if (connInfo == NULL) {
701         return;
702     }
703     ret = AuthDeviceGetPreferConnInfo(NULL, connInfo);
704     connInfo->type = AUTH_LINK_TYPE_BLE;
705     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
706     SoftBusFree(connInfo);
707 }
708 
709 /*
710  * @tc.name: AUTH_DEVICE_CHECK_CONN_INFO_TEST_001
711  * @tc.desc: fsm msg type to str test
712  * @tc.type: FUNC
713  * @tc.require:
714  */
715 HWTEST_F(AuthOtherTest, AUTH_DEVICE_CHECK_CONN_INFO_TEST_001, TestSize.Level1)
716 {
717     const char *uuid = "test66";
718     AuthLinkType type = AUTH_LINK_TYPE_WIFI;
719     bool checkConnection = false;
720     bool ret = AuthDeviceCheckConnInfo(uuid, type, checkConnection);
721     EXPECT_TRUE(ret == false);
722 }
723 
724 /*
725  * @tc.name: CONVERT_AUTH_LINK_TYPE_TO_HISYSEVENT_LINKTYPE_TEST_001
726  * @tc.desc: sync deviceInfo state process test
727  * @tc.type: FUNC
728  * @tc.require:
729  */
730 HWTEST_F(AuthOtherTest, CONVERT_AUTH_LINK_TYPE_TO_HISYSEVENT_LINKTYPE_TEST_001, TestSize.Level1)
731 {
732     AuthFsm *authFsm = (AuthFsm *)SoftBusCalloc(sizeof(AuthFsm));
733     ASSERT_TRUE(authFsm != nullptr);
734     authFsm->info.connInfo.type = (AuthLinkType)(AUTH_LINK_TYPE_WIFI - 1);
735     ReportAuthResultEvt(authFsm, 0);
736 
737     authFsm->info.connInfo.type = AUTH_LINK_TYPE_WIFI;
738     SoftBusLinkType ret = ConvertAuthLinkTypeToHisysEvtLinkType(AUTH_LINK_TYPE_WIFI);
739     EXPECT_TRUE(ret == SOFTBUS_HISYSEVT_LINK_TYPE_WLAN);
740 
741     authFsm->info.connInfo.type = AUTH_LINK_TYPE_BR;
742     ret = ConvertAuthLinkTypeToHisysEvtLinkType(AUTH_LINK_TYPE_BR);
743     EXPECT_TRUE(ret == SOFTBUS_HISYSEVT_LINK_TYPE_BR);
744 
745     authFsm->info.connInfo.type = AUTH_LINK_TYPE_BLE;
746     ret = ConvertAuthLinkTypeToHisysEvtLinkType(AUTH_LINK_TYPE_BLE);
747     EXPECT_TRUE(ret == SOFTBUS_HISYSEVT_LINK_TYPE_BLE);
748 
749     authFsm->info.connInfo.type = AUTH_LINK_TYPE_P2P;
750     ret = ConvertAuthLinkTypeToHisysEvtLinkType(AUTH_LINK_TYPE_P2P);
751     EXPECT_TRUE(ret == SOFTBUS_HISYSEVT_LINK_TYPE_P2P);
752 
753     ReportAuthResultEvt(authFsm, SOFTBUS_AUTH_SEND_FAIL);
754     ReportAuthResultEvt(authFsm, SOFTBUS_AUTH_DEVICE_DISCONNECTED);
755     ReportAuthResultEvt(authFsm, SOFTBUS_AUTH_HICHAIN_PROCESS_FAIL);
756     ReportAuthResultEvt(authFsm, 11);
757     int32_t  ret1 = RecoveryFastAuthKey(authFsm);
758     EXPECT_TRUE(ret1 != SOFTBUS_OK);
759     AuthSessionInfo authSessionInfo;
760     authSessionInfo.requestId = 11;
761     authSessionInfo.isServer= false;
762     authSessionInfo.connInfo.type = AUTH_LINK_TYPE_WIFI;
763     const char *udid = "1111";
764     (void)strcpy_s(authSessionInfo.udid, UDID_BUF_LEN, udid);
765     authFsm->info = authSessionInfo;
766     authFsm->authSeq = 512;
767     const uint8_t *data = reinterpret_cast<const uint8_t *>(malloc(sizeof(uint8_t)));
768     ASSERT_TRUE(data != nullptr);
769     MessagePara *para = NewMessagePara(data, MSG_LEN);
770     HandleMsgRecvDeviceInfo(authFsm, para);
771     authSessionInfo.isServer= true;
772     HandleMsgRecvDeviceInfo(authFsm, para);
773     SoftBusFree(authFsm);
774 }
775 
776 /*
777  * @tc.name: POST_MESSAGE_TO_AUTH_FSM_TEST_001
778  * @tc.desc: post message to auth fsm test
779  * @tc.type: FUNC
780  * @tc.require:
781  */
782 HWTEST_F(AuthOtherTest, POST_MESSAGE_TO_AUTH_FSM_TEST_001, TestSize.Level1)
783 {
784     int32_t msgType = 1;
785     int64_t authSeq = 0;
786     const uint8_t *data = reinterpret_cast<const uint8_t *>(malloc(sizeof(uint8_t)));
787     ASSERT_TRUE(data != nullptr);
788     uint32_t len = 0;
789     int32_t ret = PostMessageToAuthFsm(msgType, authSeq, data, len);
790     EXPECT_TRUE(ret != SOFTBUS_OK);
791     len = MSG_LEN;
792     ret = PostMessageToAuthFsm(msgType, authSeq, data, len);
793     EXPECT_TRUE(ret != SOFTBUS_OK);
794 }
795 
796 /*
797  * @tc.name: AUTH_FSM_TEST_001
798  * @tc.desc: authSession handle device disconnected test
799  * @tc.type: FUNC
800  * @tc.require:
801  */
802 HWTEST_F(AuthOtherTest, AUTH_FSM_TEST_001, TestSize.Level1)
803 {
804     uint64_t connId = 111;
805     bool isServer = true;
806     AuthFsm* ret = GetAuthFsmByConnId(connId, isServer, false);
807     EXPECT_TRUE(ret == NULL);
808     int32_t ret1 = AuthSessionHandleDeviceDisconnected(connId);
809     EXPECT_TRUE(ret1 == SOFTBUS_OK);
810 }
811 
812 /*
813  * @tc.name: AUTH_RESTORE_MANAGER_TEST_001
814  * @tc.desc: authRestore authManager test
815  * @tc.type: FUNC
816  * @tc.require:
817  */
818 HWTEST_F(AuthOtherTest, AUTH_RESTORE_MANAGER_TEST_001, TestSize.Level1)
819 {
820     AuthConnInfo *connInfo =(AuthConnInfo*)SoftBusCalloc(sizeof(AuthConnInfo));
821     if (connInfo == NULL) {
822         return;
823     }
824     connInfo->type = AUTH_LINK_TYPE_BLE;
825     uint32_t requestId = 1;
826     NodeInfo *nodeInfo = (NodeInfo*)SoftBusCalloc(sizeof(NodeInfo));
827     ASSERT_TRUE(nodeInfo != nullptr);
828     int64_t *authId = reinterpret_cast<int64_t *>(malloc(sizeof(int64_t)));
829     int32_t ret = AuthRestoreAuthManager(NULL, connInfo, requestId, nodeInfo, authId);
830     EXPECT_TRUE(ret == SOFTBUS_ERR);
831     const char *udidHash = "1234uuid";
832     ret = AuthRestoreAuthManager(udidHash, NULL, requestId, nodeInfo, authId);
833     EXPECT_TRUE(ret == SOFTBUS_ERR);
834     ret = AuthRestoreAuthManager(udidHash, connInfo, requestId, NULL, authId);
835     EXPECT_TRUE(ret == SOFTBUS_ERR);
836     ret = AuthRestoreAuthManager(udidHash, connInfo, requestId, nodeInfo, NULL);
837     EXPECT_TRUE(ret == SOFTBUS_ERR);
838     ret = AuthRestoreAuthManager(udidHash, connInfo, requestId, nodeInfo, authId);
839     EXPECT_TRUE(ret == SOFTBUS_ERR);
840     const char *udidHash1 = "testudidhashpass";
841     ret = AuthRestoreAuthManager(udidHash1, connInfo, requestId, nodeInfo, authId);
842     EXPECT_TRUE(ret == SOFTBUS_ERR);
843     SoftBusFree(connInfo);
844     SoftBusFree(nodeInfo);
845 }
846 
847 /*
848  * @tc.name: GET_PEER_UDID_BY_NETWORK_ID_TEST_001
849  * @tc.desc: get peer udid by networkId test
850  * @tc.type: FUNC
851  * @tc.require:
852  */
853 HWTEST_F(AuthOtherTest, GET_PEER_UDID_BY_NETWORK_ID_TEST_001, TestSize.Level1)
854 {
855     const char *networkId = "testudid";
856     int32_t ret = GetPeerUdidByNetworkId(networkId, nullptr, UDID_BUF_LEN);
857     char udid[UDID_BUF_LEN] = {0};
858     ret = GetPeerUdidByNetworkId(nullptr, udid, UDID_BUF_LEN);
859     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
860     ret = GetPeerUdidByNetworkId(networkId, udid, UDID_BUF_LEN);
861     EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
862 }
863 
864 /*
865  * @tc.name: GET_LATEST_ID_BY_CONNINFO_TEST_001
866  * @tc.desc: get latest id by connInfo test
867  * @tc.type: FUNC
868  * @tc.require:
869  */
870 HWTEST_F(AuthOtherTest, GET_LATEST_ID_BY_CONNINFO_TEST_001, TestSize.Level1)
871 {
872     int64_t ret = GetLatestIdByConnInfo(NULL);
873     EXPECT_TRUE(ret == AUTH_INVALID_ID);
874     AuthConnInfo *connInfo = (AuthConnInfo *)SoftBusCalloc(sizeof(AuthConnInfo));
875     ASSERT_TRUE(connInfo != nullptr);
876     connInfo->type = AUTH_LINK_TYPE_WIFI;
877     const char *ip = "192.168.12.1";
878     (void)strcpy_s(connInfo->info.ipInfo.ip, IP_LEN, ip);
879     ret = GetLatestIdByConnInfo(connInfo);
880     EXPECT_TRUE(ret == AUTH_INVALID_ID);
881     connInfo->type = AUTH_LINK_TYPE_BLE;
882     ret = GetLatestIdByConnInfo(connInfo);
883     EXPECT_TRUE(ret == AUTH_INVALID_ID);
884     SoftBusFree(connInfo);
885 }
886 
887 /*
888  * @tc.name: START_RECONNECT_DEVICE_TEST_001
889  * @tc.desc: start reconnection device test
890  * @tc.type: FUNC
891  * @tc.require:
892  */
893 HWTEST_F(AuthOtherTest, START_RECONNECT_DEVICE_TEST_001, TestSize.Level1)
894 {
895     AuthConnInfo connInfo;
896     AuthConnCallback connCb;
897     AuthHandle authHandle = { .authId = 1, .type = AUTH_LINK_TYPE_WIFI };
898     int32_t ret = AuthStartReconnectDevice(authHandle, &connInfo, 1, &connCb);
899     EXPECT_TRUE(ret == SOFTBUS_AUTH_NOT_FOUND);
900 
901     NodeInfo nodeInfo;
902     ReportAuthRequestPassed(11, authHandle, &nodeInfo);
903     AuthRequest request;
904     uint64_t connId = 10;
905     int32_t result = 1;
906     HandleReconnectResult(&request, connId, result, 0);
907     request.authId = 10;
908     request.requestId = 11;
909     HandleReconnectResult(&request, connId, result, 0);
910 }
911 
912 /*
913  * @tc.name: AUTH_GET_LATEST_AUTHSEQ_LIST_TEST_001
914  * @tc.desc: auth get latest authsed list test
915  * @tc.type: FUNC
916  * @tc.require:
917  */
918 HWTEST_F(AuthOtherTest, AUTH_GET_LATEST_AUTHSEQ_LIST_TEST_001, TestSize.Level1)
919 {
920     int64_t seqList = 1024;
921     uint32_t num = 1;
922     int32_t ret = AuthGetLatestAuthSeqList(NULL, &seqList, num);
923     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
924     const char *udid = "";
925     ret = AuthGetLatestAuthSeqList(udid, &seqList, num);
926     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
927     const char *udid1 = "11";
928     ret = AuthGetLatestAuthSeqList(udid1, NULL, num);
929     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
930     ret = AuthGetLatestAuthSeqList(udid1, &seqList, num);
931     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
932     num = DISCOVERY_TYPE_COUNT;
933     ret = AuthGetLatestAuthSeqList(udid1, &seqList, num);
934     EXPECT_TRUE(ret == SOFTBUS_AUTH_NOT_FOUND);
935 
936     AuthConnInfo connInfo;
937     AuthDataHead head;
938     uint8_t data = 1;
939     head.flag = 0;
940     connInfo.type = AUTH_LINK_TYPE_BLE;
941     uint64_t connId = 11;
942     HandleDeviceInfoData(connId, &connInfo, false, &head, &data);
943     head.flag = 1;
944     HandleDeviceInfoData(connId, &connInfo, false, &head, &data);
945 }
946 
947 
948 /*
949  * @tc.name: SYNC_DEVINFO_STATE_PROCESS_TEST_001
950  * @tc.desc: sync deviceInfo state process test
951  * @tc.type: FUNC
952  * @tc.require:
953  */
954 HWTEST_F(AuthOtherTest, SYNC_DEVINFO_STATE_PROCESS_TEST_001, TestSize.Level1)
955 {
956     FsmStateMachine *fsm = (FsmStateMachine *)SoftBusCalloc(sizeof(FsmStateMachine));
957     ASSERT_TRUE(fsm != nullptr);
958     int32_t msgType = 1;
959     bool ret = SyncDevInfoStateProcess(fsm, msgType, NULL);
960     EXPECT_TRUE(ret == false);
961     SoftBusFree(fsm);
962     FsmStateMachine *testFsm = (FsmStateMachine *)SoftBusCalloc(sizeof(FsmStateMachine));
963     ASSERT_TRUE(testFsm != nullptr);
964     testFsm->flag = 1;
965 
966     ret = SyncDevInfoStateProcess(testFsm, msgType, NULL);
967     EXPECT_TRUE(ret == false);
968 
969     msgType = FSM_MSG_AUTH_TIMEOUT;
970     ret = SyncDevInfoStateProcess(testFsm, msgType, NULL);
971     msgType = FSM_MSG_RECV_DEVICE_INFO;
972     ret = SyncDevInfoStateProcess(testFsm, msgType, NULL);
973     EXPECT_TRUE(ret == false);
974 
975     msgType = FSM_MSG_RECV_CLOSE_ACK;
976     ret = SyncDevInfoStateProcess(testFsm, msgType, NULL);
977     EXPECT_TRUE(ret == false);
978 
979     msgType = FSM_MSG_RECV_AUTH_DATA;
980     ret = SyncDevInfoStateProcess(testFsm, msgType, NULL);
981     EXPECT_TRUE(ret == false);
982 
983     msgType = FSM_MSG_AUTH_FINISH;
984     ret = SyncDevInfoStateProcess(testFsm, msgType, NULL);
985     EXPECT_TRUE(ret == false);
986     SoftBusFree(testFsm);
987 }
988 
989 /*
990  * @tc.name: GET_AUTH_CONN_001
991  * @tc.desc: get auth conn test
992  * @tc.type: FUNC
993  * @tc.require:
994  */
995 HWTEST_F(AuthOtherTest, GET_AUTH_CONN_001, TestSize.Level1)
996 {
997     const char *uuid = "testuuid123";
998 
999     AuthConnInfo *connInfo = (AuthConnInfo *)SoftBusCalloc(sizeof(AuthConnInfo));
1000     ASSERT_TRUE(connInfo != nullptr);
1001 
1002     int32_t ret = GetAuthConn(uuid, LANE_BR, nullptr);
1003     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1004 
1005     ret = GetAuthConn(nullptr, LANE_BR, connInfo);
1006     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1007 
1008     connInfo->type = AUTH_LINK_TYPE_BR;
1009     ret = GetAuthConn(uuid, LANE_BR, connInfo);
1010     EXPECT_TRUE(ret == SOFTBUS_AUTH_NOT_FOUND);
1011 
1012     connInfo->type = AUTH_LINK_TYPE_BLE;
1013     ret = GetAuthConn(uuid, LANE_BLE, connInfo);
1014     EXPECT_TRUE(ret == SOFTBUS_AUTH_NOT_FOUND);
1015 
1016     connInfo->type = AUTH_LINK_TYPE_P2P;
1017     ret = GetAuthConn(uuid, LANE_P2P, connInfo);
1018     EXPECT_TRUE(ret == SOFTBUS_AUTH_NOT_FOUND);
1019 
1020     ret = GetAuthConn(uuid, LANE_HML, connInfo);
1021     EXPECT_TRUE(ret == SOFTBUS_AUTH_NOT_FOUND);
1022 
1023     ret = GetAuthConn(uuid, LANE_WLAN_2P4G, connInfo);
1024     EXPECT_TRUE(ret == SOFTBUS_AUTH_NOT_FOUND);
1025 
1026     SoftBusFree(connInfo);
1027 }
1028 
1029 /*
1030  * @tc.name: AUTH_GET_AUTH_HANDLE_BY_INDEX_TEST_001
1031  * @tc.desc: AuthGetAuthHandleByIndex test
1032  * @tc.type: FUNC
1033  * @tc.require:
1034  */
1035 HWTEST_F(AuthOtherTest, AUTH_GET_AUTH_HANDLE_BY_INDEX_TEST_001, TestSize.Level1)
1036 {
1037     AuthConnInfo connInfo = {
1038         .info.ipInfo.ip = "192.168.12.1",
1039         .type = AUTH_LINK_TYPE_WIFI,
1040     };
1041     AuthHandle authHandle;
1042     (void)memset_s(&authHandle, sizeof(AuthHandle), 0, sizeof(AuthHandle));
1043     EXPECT_TRUE(AuthGetAuthHandleByIndex(nullptr, true, 1, &authHandle) == SOFTBUS_INVALID_PARAM);
1044     EXPECT_TRUE(AuthGetAuthHandleByIndex(&connInfo, true, 1, nullptr) == SOFTBUS_INVALID_PARAM);
1045     EXPECT_TRUE(AuthGetAuthHandleByIndex(&connInfo, true, 1, &authHandle) == SOFTBUS_LOCK_ERR);
1046     char UDID_TEST[UDID_BUF_LEN] = "123456789udidtest";
1047     connInfo.type = AUTH_LINK_TYPE_BLE;
1048     ASSERT_TRUE(memcpy_s(connInfo.info.bleInfo.deviceIdHash, UDID_HASH_LEN, UDID_TEST, strlen(UDID_TEST)) == EOK);
1049     EXPECT_TRUE(AuthGetAuthHandleByIndex(&connInfo, true, 1, &authHandle) == SOFTBUS_NOT_FIND);
1050     char BR_MAC[BT_MAC_LEN] = "00:15:5d:de:d4:23";
1051     connInfo.type = AUTH_LINK_TYPE_BR;
1052     ASSERT_TRUE(memcpy_s(connInfo.info.brInfo.brMac, BT_MAC_LEN, BR_MAC, strlen(BR_MAC)) == EOK);
1053     EXPECT_TRUE(AuthGetAuthHandleByIndex(&connInfo, true, 1, &authHandle) == SOFTBUS_LOCK_ERR);
1054     connInfo.type = AUTH_LINK_TYPE_MAX;
1055     EXPECT_TRUE(AuthGetAuthHandleByIndex(&connInfo, true, 1, &authHandle) == SOFTBUS_INVALID_PARAM);
1056 }
1057 
1058 /*
1059  * @tc.name: AUTH_CHECK_SESSION_KEY_VALID_BY_CONN_INFO_TEST_001
1060  * @tc.desc: AuthCheckSessionKeyValidByConnInfo test
1061  * @tc.type: FUNC
1062  * @tc.require:
1063  */
1064 HWTEST_F(AuthOtherTest, AUTH_CHECK_SESSION_KEY_VALID_BY_CONN_INFO_TEST_001, TestSize.Level1)
1065 {
1066     const char *networkId = "123456456";
1067     AuthConnInfo connInfo;
1068     EXPECT_TRUE(AuthCheckSessionKeyValidByConnInfo(nullptr, &connInfo) == SOFTBUS_INVALID_PARAM);
1069     EXPECT_TRUE(AuthCheckSessionKeyValidByConnInfo(networkId, nullptr) == SOFTBUS_INVALID_PARAM);
1070     EXPECT_TRUE(AuthCheckSessionKeyValidByConnInfo(networkId, &connInfo) == SOFTBUS_NETWORK_GET_NODE_INFO_ERR);
1071     EXPECT_TRUE(AuthCheckSessionKeyValidByAuthHandle(nullptr) == SOFTBUS_INVALID_PARAM);
1072     AuthHandle authHandle = { .type = AUTH_LINK_TYPE_WIFI, .authId = 0, };
1073     EXPECT_TRUE(AuthCheckSessionKeyValidByAuthHandle(&authHandle) == SOFTBUS_AUTH_SESSION_KEY_INVALID);
1074     authHandle.type = -1;
1075     AuthTransData dataInfo;
1076     AuthCloseConn(authHandle);
1077     EXPECT_TRUE(AuthPostTransData(authHandle, &dataInfo) == SOFTBUS_INVALID_PARAM);
1078     EXPECT_TRUE(AuthGetConnInfo(authHandle, &connInfo) == SOFTBUS_INVALID_PARAM);
1079     authHandle.type = AUTH_LINK_TYPE_MAX;
1080     AuthCloseConn(authHandle);
1081     EXPECT_TRUE(AuthPostTransData(authHandle, &dataInfo) == SOFTBUS_INVALID_PARAM);
1082     EXPECT_TRUE(AuthGetConnInfo(authHandle, &connInfo) == SOFTBUS_INVALID_PARAM);
1083     AuthFreeConn(nullptr);
1084     AuthFreeConn(&authHandle);
1085     AuthConnCallback callback;
1086     EXPECT_TRUE(AuthAllocConn(nullptr, 1, &callback) == SOFTBUS_INVALID_PARAM);
1087     EXPECT_TRUE(AuthAllocConn(networkId, 1, nullptr) == SOFTBUS_INVALID_PARAM);
1088     EXPECT_TRUE(AuthAllocConn(nullptr, 1, nullptr) == SOFTBUS_INVALID_PARAM);
1089     EXPECT_TRUE(AuthGetP2pConnInfo(nullptr, nullptr, true) == AUTH_INVALID_ID);
1090     EXPECT_TRUE(AuthGetHmlConnInfo(nullptr, nullptr, true) == AUTH_INVALID_ID);
1091     AuthGetLatestIdByUuid(nullptr, AUTH_LINK_TYPE_WIFI, true, nullptr);
1092     AuthGetLatestIdByUuid(nullptr, AUTH_LINK_TYPE_WIFI, true, &authHandle);
1093 }
1094 
1095 /*
1096  * @tc.name: AUTH_DIRECT_ONLINE_PROCESS_SESSION_KEY_TEST_001
1097  * @tc.desc: AuthDirectOnlineProcessSessionKey test
1098  * @tc.type: FUNC
1099  * @tc.require:
1100  */
1101 HWTEST_F(AuthOtherTest, AUTH_DIRECT_ONLINE_PROCESS_SESSION_KEY_TEST_001, TestSize.Level1)
1102 {
1103     AuthDeviceKeyInfo keyInfo = { .keyLen = strlen("testKey"), .isOldKey = true, };
1104     ASSERT_TRUE(memcpy_s(keyInfo.deviceKey, SESSION_KEY_LENGTH, "testKey", strlen("testKey")) == EOK);
1105     AuthSessionInfo info = { .connInfo.type = AUTH_LINK_TYPE_BR, };
1106     int64_t authId;
1107     EXPECT_TRUE(AuthDirectOnlineProcessSessionKey(&info, &keyInfo, &authId) == SOFTBUS_ERR);
1108     EXPECT_TRUE(AuthDirectOnlineWithoutSessionKey(&info, &keyInfo, &authId) == SOFTBUS_ERR);
1109     EXPECT_TRUE(AuthEncrypt(nullptr, nullptr, 0, nullptr, nullptr) == SOFTBUS_INVALID_PARAM);
1110     EXPECT_TRUE(AuthDecrypt(nullptr, nullptr, 0, nullptr, nullptr) == SOFTBUS_INVALID_PARAM);
1111 }
1112 
1113 /*
1114  * @tc.name: IS_SAME_ACCOUNT_DEVICE_TEST_001
1115  * @tc.desc: IsSameAccountDevice test
1116  * @tc.type: FUNC
1117  * @tc.require:
1118  */
1119 HWTEST_F(AuthOtherTest, IS_SAME_ACCOUNT_DEVICE_TEST_001, TestSize.Level1)
1120 {
1121     EXPECT_TRUE(LnnInitLocalLedger() == SOFTBUS_OK);
1122     uint8_t accountHash[SHA_256_HASH_LEN] = "accounthashtest";
1123     EXPECT_TRUE(LnnSetLocalByteInfo(BYTE_KEY_ACCOUNT_HASH, accountHash, SHA_256_HASH_LEN) == SOFTBUS_OK);
1124     EXPECT_TRUE(AuthIsPotentialTrusted(nullptr) == false);
1125     DeviceInfo device = { .devId = "testId", .accountHash = "accounthashtest", };
1126     EXPECT_TRUE(AuthIsPotentialTrusted(&device) == true);
1127     EXPECT_TRUE(IsSameAccountDevice(nullptr) == false);
1128     EXPECT_TRUE(IsSameAccountDevice(&device) == true);
1129     EXPECT_TRUE(AuthHasSameAccountGroup() == false);
1130 }
1131 
1132 /*
1133  * @tc.name: FILL_AUTH_SESSION_INFO_TEST_001
1134  * @tc.desc: FillAuthSessionInfo test
1135  * @tc.type: FUNC
1136  * @tc.require:
1137  */
1138 HWTEST_F(AuthOtherTest, FILL_AUTH_SESSION_INFO_TEST_001, TestSize.Level1)
1139 {
1140     AuthSessionInfo info = { .connInfo.info.bleInfo.deviceIdHash = "123456789udidhashtest", };
1141     NodeInfo nodeInfo = {
1142         .authCapacity = 127,
1143         .uuid = "123456789uuidhashtest",
1144         .deviceInfo.deviceUdid = "123456789udidtest",
1145     };
1146     AuthDeviceKeyInfo keyInfo;
1147     EXPECT_TRUE(FillAuthSessionInfo(&info, &nodeInfo, &keyInfo, true) == SOFTBUS_OK);
1148     EXPECT_TRUE(FillAuthSessionInfo(&info, &nodeInfo, &keyInfo, false) == SOFTBUS_OK);
1149 }
1150 
1151 /*
1152  * @tc.name: DEL_AUTH_REQ_INFO_BY_AUTH_HANDLE_TEST_001
1153  * @tc.desc: DelAuthReqInfoByAuthHandle test
1154  * @tc.type: FUNC
1155  * @tc.require:
1156  */
1157 HWTEST_F(AuthOtherTest, DEL_AUTH_REQ_INFO_BY_AUTH_HANDLE_TEST_001, TestSize.Level1)
1158 {
1159     InitAuthReqInfo();
1160     AuthConnCallback authConnCb = {
1161         .onConnOpened = OnConnOpenedTest,
1162         .onConnOpenFailed = OnConnOpenFailedTest,
1163     };
1164     EXPECT_EQ(AddAuthReqNode(NETWORK_ID, 1, 1, &authConnCb), SOFTBUS_OK);
1165     EXPECT_EQ(AddAuthReqNode(NETWORK_ID, 2, 2, &authConnCb), SOFTBUS_OK);
1166     EXPECT_EQ(AddAuthReqNode(NETWORK_ID, 3, 3, &authConnCb), SOFTBUS_OK);
1167     OnAuthConnOpenedFail(1, -1);
1168     OnAuthConnOpenedFail(4, -1);
1169     AuthHandle authHandle = { .authId = 2, .type = 1, };
1170     AuthFreeLane(&authHandle);
1171     EXPECT_EQ(DelAuthReqInfoByAuthHandle(&authHandle), SOFTBUS_OK);
1172     authHandle.type = 0;
1173     AuthFreeLane(&authHandle);
1174     EXPECT_EQ(DelAuthReqInfoByAuthHandle(&authHandle), SOFTBUS_OK);
1175     authHandle.authId = 1;
1176     AuthFreeLane(&authHandle);
1177     EXPECT_EQ(DelAuthReqInfoByAuthHandle(&authHandle), SOFTBUS_OK);
1178     authHandle.authId = 2;
1179     AuthFreeLane(&authHandle);
1180     EXPECT_EQ(DelAuthReqInfoByAuthHandle(&authHandle), SOFTBUS_OK);
1181     DeInitAuthReqInfo();
1182 }
1183 
1184 /*
1185  * @tc.name: IS_ENHANCE_P2P_MODULE_ID_Test_001
1186  * @tc.desc: IsEnhanceP2pModuleId test
1187  * @tc.type: FUNC
1188  * @tc.require:
1189  */
1190 HWTEST_F(AuthOtherTest, IS_ENHANCE_P2P_MODULE_ID_Test_001, TestSize.Level1)
1191 {
1192     EXPECT_EQ(IsEnhanceP2pModuleId(AUTH_ENHANCED_P2P_START), true);
1193     EXPECT_EQ(IsEnhanceP2pModuleId(DIRECT_CHANNEL_SERVER_P2P), false);
1194     EXPECT_EQ(IsEnhanceP2pModuleId(AUTH_P2P), false);
1195 }
1196 
1197 /*
1198  * @tc.name: AUTH_START_LISTENING_FOR_WIFI_DIRECT_Test_001
1199  * @tc.desc: AuthStartListeningForWifiDirect test
1200  * @tc.type: FUNC
1201  * @tc.require:
1202  */
1203 HWTEST_F(AuthOtherTest, AUTH_START_LISTENING_FOR_WIFI_DIRECT_Test_001, TestSize.Level1)
1204 {
1205     AsyncCallDeviceIdReceived(nullptr);
1206     AuthStopListeningForWifiDirect(AUTH_LINK_TYPE_P2P, AUTH_ENHANCED_P2P_START);
1207     AuthDataHead head;
1208     const uint8_t data[TEST_DATA_LEN] = { 0 };
1209     (void)memset_s(&head, sizeof(AuthDataHead), 0, sizeof(AuthDataHead));
1210     OnWiFiDataReceived(PROXY, 0, &head, data);
1211     OnWiFiDataReceived(AUTH, 0, &head, data);
1212     OnWiFiDataReceived(AUTH_P2P, 0, &head, data);
1213     OnWiFiDataReceived(AUTH_RAW_P2P_SERVER, 0, &head, data);
1214     OnWiFiDataReceived(AUTH_ENHANCED_P2P_START, 0, &head, data);
1215     const char *ip = "192.138.33.33";
1216     ListenerModule moduleId;
1217     (void)memset_s(&moduleId, sizeof(ListenerModule), 0, sizeof(ListenerModule));
1218     EXPECT_NE(AuthStartListeningForWifiDirect(AUTH_LINK_TYPE_P2P, ip, 37025, &moduleId),
1219         SOFTBUS_INVALID_PORT);
1220     EXPECT_NE(AuthStartListeningForWifiDirect(AUTH_LINK_TYPE_ENHANCED_P2P, ip, 37025, &moduleId),
1221         SOFTBUS_INVALID_PORT);
1222     EXPECT_EQ(AuthStartListeningForWifiDirect(AUTH_LINK_TYPE_WIFI, ip, 37025, &moduleId),
1223         SOFTBUS_INVALID_PARAM);
1224 }
1225 } // namespace OHOS
1226