1 /*
2  * Copyright (c) 2021-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 <cinttypes>
17 #include <gtest/gtest.h>
18 #include <securec.h>
19 #include <sys/time.h>
20 
21 #include "auth_channel.h"
22 #include "auth_common.h"
23 #include "auth_connection.h"
24 #include "auth_hichain.h"
25 #include "auth_interface.c"
26 #include "auth_interface.h"
27 #include "auth_log.h"
28 #include "auth_manager.h"
29 #include "auth_request.h"
30 #include "auth_session_fsm.h"
31 #include "auth_session_key.h"
32 #include "auth_session_message.h"
33 #include "auth_tcp_connection.c"
34 #include "auth_tcp_connection.h"
35 #include "common_list.h"
36 #include "lnn_net_builder.h"
37 #include "softbus_access_token_test.h"
38 #include "softbus_adapter_crypto.h"
39 #include "softbus_adapter_mem.h"
40 #include "softbus_errcode.h"
41 #include "softbus_socket.h"
42 
43 namespace OHOS {
44 using namespace testing::ext;
45 constexpr uint32_t TEST_DATA_LEN = 10;
46 constexpr uint32_t CRYPT_DATA_LEN = 200;
47 constexpr uint32_t ENCRYPT_OVER_HEAD_LEN_TEST = 32;
48 constexpr char P2P_MAC[BT_MAC_LEN] = "01:02:03:04:05:06";
49 constexpr char P2P_MAC2[BT_MAC_LEN] = { 0 };
50 constexpr char UUID_TEST[UUID_BUF_LEN] = "0123456789ABC";
51 constexpr char UUID_TEST2[UUID_BUF_LEN] = { 0 };
52 
53 #define LINK_TYPE      8
54 #define CLIENT_PORT    6666
55 #define KEEPALIVE_TIME 601
56 
57 class AuthTest : public testing::Test {
58 public:
59     static void SetUpTestCase();
60     static void TearDownTestCase();
61     void SetUp();
62     void TearDown();
63 };
64 
SetUpTestCase()65 void AuthTest::SetUpTestCase()
66 {
67     SetAceessTokenPermission("AuthTest");
68 }
69 
TearDownTestCase()70 void AuthTest::TearDownTestCase() {}
71 
SetUp()72 void AuthTest::SetUp()
73 {
74     AUTH_LOGI(AUTH_TEST, "AuthTest start");
75 }
76 
OnGroupCreated(const char * groupId,int32_t groupType)77 static void OnGroupCreated(const char *groupId, int32_t groupType)
78 {
79     (void)groupId;
80     (void)groupType;
81     return;
82 }
83 
OnGroupDeleted(const char * groupId,int32_t groupType)84 static void OnGroupDeleted(const char *groupId, int32_t groupType)
85 {
86     (void)groupId;
87     (void)groupType;
88     return;
89 }
90 
OnDeviceNotTrusted(const char * udid)91 static void OnDeviceNotTrusted(const char *udid)
92 {
93     (void)udid;
94     return;
95 }
96 
OnDeviceBound(const char * udid,const char * groupInfo)97 static void OnDeviceBound(const char *udid, const char *groupInfo)
98 {
99     (void)udid;
100     (void)groupInfo;
101     return;
102 }
103 
TearDown()104 void AuthTest::TearDown() {}
105 
106 /*
107  * @tc.name: AUTH_COMMON_Test_001
108  * @tc.desc: auth commone test
109  * @tc.type: FUNC
110  * @tc.require:
111  */
112 HWTEST_F(AuthTest, AUTH_COMMON_Test_001, TestSize.Level1)
113 {
114     int32_t ret = AuthCommonInit();
115     EXPECT_TRUE(ret == SOFTBUS_OK);
116 }
117 
118 /*
119  * @tc.name: REG_TRUST_DATA_CHANGE_LISTENER_Test_001
120  * @tc.desc: trust data change listener test
121  * @tc.type: FUNC
122  * @tc.require:
123  */
124 HWTEST_F(AuthTest, REG_TRUST_DATA_CHANGE_LISTENER_Test_001, TestSize.Level1)
125 {
126     int32_t ret;
127     const TrustDataChangeListener listener = {
128         .onGroupCreated = OnGroupCreated,
129         .onGroupDeleted = OnGroupDeleted,
130         .onDeviceNotTrusted = OnDeviceNotTrusted,
131         .onDeviceBound = OnDeviceBound,
132     };
133 
134     ret = RegTrustDataChangeListener(nullptr);
135     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
136     ret = RegTrustDataChangeListener(&listener);
137     EXPECT_TRUE(ret == SOFTBUS_OK || ret == SOFTBUS_AUTH_REG_DATA_FAIL);
138 }
139 
140 /*
141  * @tc.name: HICHAIN_START_AUTH_Test_001
142  * @tc.desc: hichain start auth test
143  * @tc.type: FUNC
144  * @tc.require:
145  */
146 HWTEST_F(AuthTest, HICHAIN_START_AUTH_Test_001, TestSize.Level1)
147 {
148     int64_t authSeq = 0;
149     const char *udid = "testdata";
150     const char *uid = "testdata";
151     int32_t ret;
152 
153     ret = HichainStartAuth(authSeq, nullptr, uid);
154     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
155     ret = HichainStartAuth(authSeq, udid, nullptr);
156     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
157     (void)HichainStartAuth(authSeq, udid, uid);
158 }
159 
160 /*
161  * @tc.name: HICHAIN_PROCESS_DATA_Test_001
162  * @tc.desc: hichain process data test
163  * @tc.type: FUNC
164  * @tc.require:
165  */
166 HWTEST_F(AuthTest, HICHAIN_PROCESS_DATA_Test_001, TestSize.Level1)
167 {
168     int64_t authSeq = 0;
169     const uint8_t data[TEST_DATA_LEN] = { 0 };
170     uint32_t len = TEST_DATA_LEN;
171     int32_t ret;
172 
173     ret = HichainProcessData(authSeq, nullptr, len);
174     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
175     ret = HichainProcessData(authSeq, data, len);
176     EXPECT_TRUE(ret == SOFTBUS_ERR);
177 }
178 
179 /*
180  * @tc.name: ADD_AUTH_REQUEST_Test_001
181  * @tc.desc: add auth request test
182  * @tc.type: FUNC
183  * @tc.require:
184  */
185 HWTEST_F(AuthTest, ADD_AUTH_REQUEST_Test_001, TestSize.Level1)
186 {
187     const AuthRequest request = { 0 };
188 
189     int32_t ret = AddAuthRequest(&request);
190     EXPECT_TRUE(ret == SOFTBUS_OK);
191 }
192 
193 /*
194  * @tc.name: GET_AUTH_REQUEST_Test_001
195  * @tc.desc: get auth request test
196  * @tc.type: FUNC
197  * @tc.require:
198  */
199 HWTEST_F(AuthTest, GET_AUTH_REQUEST_Test_001, TestSize.Level1)
200 {
201     uint32_t requestId = 1;
202     AuthRequest request = { 0 };
203 
204     int32_t ret = GetAuthRequest(requestId, &request);
205     EXPECT_TRUE(ret == SOFTBUS_NOT_FIND);
206 }
207 
208 /*
209  * @tc.name: AUTH_SESSION_PROCESS_DEVID_DATA_Test_001
210  * @tc.desc: auth session process devId data test
211  * @tc.type: FUNC
212  * @tc.require:
213  */
214 HWTEST_F(AuthTest, AUTH_SESSION_PROCESS_DEVID_DATA_Test_001, TestSize.Level1)
215 {
216     int64_t authSeq = 0;
217     uint32_t len = 1;
218     int32_t ret;
219 
220     ret = AuthSessionProcessDevIdData(authSeq, nullptr, len);
221     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
222 }
223 
224 /*
225  * @tc.name: AUTH_SESSION_POST_AUTH_DATA_Test_001
226  * @tc.desc: auth session post auth data test
227  * @tc.type: FUNC
228  * @tc.require:
229  */
230 HWTEST_F(AuthTest, AUTH_SESSION_POST_AUTH_DATA_Test_001, TestSize.Level1)
231 {
232     int64_t authSeq = -1;
233     uint32_t len = 1;
234     int32_t ret;
235 
236     ret = AuthSessionPostAuthData(authSeq, nullptr, len);
237     EXPECT_TRUE(ret != SOFTBUS_OK);
238 }
239 
240 /*
241  * @tc.name: AUTH_SESSION_PROCESS_AUTH_DATA_Test_001
242  * @tc.desc: auth session process auth data test
243  * @tc.type: FUNC
244  * @tc.require:
245  */
246 HWTEST_F(AuthTest, AUTH_SESSION_PROCESS_AUTH_DATA_Test_001, TestSize.Level1)
247 {
248     int64_t authSeq = 0;
249     uint32_t len = 1;
250     int32_t ret;
251 
252     ret = AuthSessionProcessAuthData(authSeq, nullptr, len);
253     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
254 }
255 
256 /*
257  * @tc.name: AUTH_SESSION_GET_UDID_Test_001
258  * @tc.desc: auth session get udid test
259  * @tc.type: FUNC
260  * @tc.require:
261  */
262 HWTEST_F(AuthTest, AUTH_SESSION_GET_UDID_Test_001, TestSize.Level1)
263 {
264     int64_t authSeq = 0;
265     char udid[UDID_BUF_LEN] = { 0 };
266     uint32_t size = UDID_BUF_LEN;
267     int32_t ret;
268 
269     ret = AuthSessionGetUdid(authSeq, nullptr, size);
270     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
271     authSeq = -1;
272     ret = AuthSessionGetUdid(authSeq, udid, size);
273     EXPECT_TRUE(ret != SOFTBUS_OK);
274 }
275 
276 /*
277  * @tc.name: AUTH_SESSION_SAVE_SESSIONKEY_Test_001
278  * @tc.desc: auth session save sessionKey test
279  * @tc.type: FUNC
280  * @tc.require:
281  */
282 HWTEST_F(AuthTest, AUTH_SESSION_SAVE_SESSIONKEY_Test_001, TestSize.Level1)
283 {
284     int64_t authSeq = 0;
285     uint32_t len = 1;
286     int32_t ret;
287 
288     ret = AuthSessionSaveSessionKey(authSeq, nullptr, len);
289     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
290 }
291 
292 /*
293  * @tc.name: AUTH_SESSION_PROCESS_DEVINFO_DATA_Test_001
294  * @tc.desc: auth session process devInfo data test
295  * @tc.type: FUNC
296  * @tc.require:
297  */
298 HWTEST_F(AuthTest, AUTH_SESSION_PROCESS_DEVINFO_DATA_Test_001, TestSize.Level1)
299 {
300     int64_t authSeq = 0;
301     uint32_t len = 1;
302     int32_t ret;
303 
304     ret = AuthSessionProcessDevInfoData(authSeq, nullptr, len);
305     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
306 }
307 
308 /*
309  * @tc.name: AUTH_SESSION_PROCESS_CLOSE_ACK_Test_001
310  * @tc.desc: auth session process close ack test
311  * @tc.type: FUNC
312  * @tc.require:
313  */
314 HWTEST_F(AuthTest, AUTH_SESSION_PROCESS_CLOSE_ACK_Test_001, TestSize.Level1)
315 {
316     int64_t authSeq = 0;
317     uint32_t len = 1;
318     int32_t ret;
319 
320     ret = AuthSessionProcessCloseAck(authSeq, nullptr, len);
321     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
322 }
323 
324 /*
325  * @tc.name: AUTH_SESSION_PROCESS_CLOSE_ACK_BY_CONNID_Test_001
326  * @tc.desc: auth session process close ack by connId test
327  * @tc.type: FUNC
328  * @tc.require:
329  */
330 HWTEST_F(AuthTest, AUTH_SESSION_PROCESS_CLOSE_ACK_BY_CONNID_Test_001, TestSize.Level1)
331 {
332     uint64_t connId = 0;
333     bool isServer = true;
334     const uint8_t data[TEST_DATA_LEN] = { 0 };
335     uint32_t len = TEST_DATA_LEN;
336     int32_t ret;
337 
338     ret = AuthSessionProcessCloseAckByConnId(connId, isServer, nullptr, len);
339     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
340     ret = AuthSessionProcessCloseAckByConnId(connId, isServer, data, len);
341     EXPECT_TRUE(ret != SOFTBUS_OK);
342 }
343 
344 /*
345  * @tc.name: AUTH_SESSION_PROCESS_CANCEL_AUTH_BY_CONNID_Test_001
346  * @tc.desc: auth session process cancel auth by connId test
347  * @tc.type: FUNC
348  * @tc.require:
349  */
350 HWTEST_F(AuthTest, AUTH_SESSION_PROCESS_CANCEL_AUTH_BY_CONNID_Test_001, TestSize.Level1)
351 {
352     uint64_t connId = 0;
353     bool isServer = true;
354     const uint8_t data[TEST_DATA_LEN] = { 0 };
355     uint32_t len = TEST_DATA_LEN;
356     int32_t ret;
357 
358     ret = AuthSessionProcessCancelAuthByConnId(connId, isServer, nullptr, len);
359     EXPECT_TRUE(ret == SOFTBUS_AUTH_GET_FSM_FAIL);
360     ret = AuthSessionProcessCancelAuthByConnId(connId, isServer, data, len);
361     EXPECT_TRUE(ret == SOFTBUS_AUTH_GET_FSM_FAIL);
362     ret = AuthSessionProcessCancelAuthByConnId(connId, !isServer, data, len);
363     EXPECT_TRUE(ret == SOFTBUS_AUTH_GET_FSM_FAIL);
364     ret = AuthSessionProcessCancelAuthByConnId(connId, !isServer, nullptr, len);
365     EXPECT_TRUE(ret == SOFTBUS_AUTH_GET_FSM_FAIL);
366 }
367 
368 /*
369  * @tc.name: AUTH_SESSION_HANDLE_DEVICE_NOT_TRUSTED_Test_001
370  * @tc.desc: auth session handle device not trusted test
371  * @tc.type: FUNC
372  * @tc.require:
373  */
374 HWTEST_F(AuthTest, AUTH_SESSION_HANDLE_DEVICE_NOT_TRUSTED_Test_001, TestSize.Level1)
375 {
376     const char *udid = "testdata";
377     int32_t ret;
378 
379     ret = AuthSessionHandleDeviceNotTrusted(nullptr);
380     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
381     ret = AuthSessionHandleDeviceNotTrusted(udid);
382     EXPECT_TRUE(ret == SOFTBUS_OK);
383     const char *udid1 = "";
384     ret = AuthSessionHandleDeviceNotTrusted(udid1);
385     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
386 }
387 
388 /*
389  * @tc.name: ENCRYPT_INNER_Test_001
390  * @tc.desc: encrypt inner test
391  * @tc.type: FUNC
392  * @tc.require:
393  */
394 HWTEST_F(AuthTest, ENCRYPT_INNER_Test_001, TestSize.Level1)
395 {
396     SessionKeyList list = { 0 };
397     SessionKey sessionKey = { { 0 }, TEST_DATA_LEN };
398     int64_t authSeq = 0;
399     const uint8_t inData[CRYPT_DATA_LEN] = { 0 };
400     uint8_t *outData = nullptr;
401     uint32_t outLen = 0;
402     int32_t ret;
403     InDataInfo inDataInfo = { .inData = nullptr, .inLen = CRYPT_DATA_LEN };
404     ret = EncryptInner(&list, AUTH_LINK_TYPE_WIFI, &inDataInfo, &outData, &outLen);
405     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
406     SoftBusFree(outData);
407     inDataInfo.inData = inData;
408     ret = EncryptInner(nullptr, AUTH_LINK_TYPE_WIFI, &inDataInfo, &outData, &outLen);
409     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
410     SoftBusFree(outData);
411     ret = EncryptInner(&list, AUTH_LINK_TYPE_WIFI, &inDataInfo, nullptr, &outLen);
412     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
413     SoftBusFree(outData);
414     ret = EncryptInner(&list, AUTH_LINK_TYPE_WIFI, &inDataInfo, &outData, nullptr);
415     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
416     SoftBusFree(outData);
417     inDataInfo.inLen = 0;
418     ret = EncryptInner(&list, AUTH_LINK_TYPE_WIFI, &inDataInfo, &outData, nullptr);
419     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
420     SoftBusFree(outData);
421     ListInit(&list);
422     ret = AddSessionKey(&list, TO_INT32(authSeq), &sessionKey, AUTH_LINK_TYPE_WIFI, false);
423     EXPECT_TRUE(ret == SOFTBUS_OK);
424     inDataInfo.inLen = CRYPT_DATA_LEN;
425     ret = EncryptInner(&list, AUTH_LINK_TYPE_WIFI, &inDataInfo, &outData, &outLen);
426     EXPECT_TRUE(ret == SOFTBUS_ENCRYPT_ERR);
427     SoftBusFree(outData);
428 }
429 
430 /*
431  * @tc.name: DENCRYPT_INNER_Test_001
432  * @tc.desc: dencrypt inner test
433  * @tc.type: FUNC
434  * @tc.require:
435  */
436 HWTEST_F(AuthTest, DENCRYPT_INNER_Test_001, TestSize.Level1)
437 {
438     SessionKeyList list = { 0 };
439     SessionKey sessionKey = { { 0 }, TEST_DATA_LEN };
440     int64_t authSeq = 0;
441     const uint8_t inData[CRYPT_DATA_LEN] = { 0 };
442     uint8_t *outData = nullptr;
443     uint32_t outLen = 0;
444     int32_t ret;
445     InDataInfo inDataInfo = { .inData = nullptr, .inLen = CRYPT_DATA_LEN };
446     ret = DecryptInner(&list, AUTH_LINK_TYPE_WIFI, &inDataInfo, &outData, &outLen);
447     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
448     SoftBusFree(outData);
449     inDataInfo.inData = inData;
450     ret = DecryptInner(nullptr, AUTH_LINK_TYPE_WIFI, &inDataInfo, &outData, &outLen);
451     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
452     SoftBusFree(outData);
453     ret = DecryptInner(&list, AUTH_LINK_TYPE_WIFI, &inDataInfo, nullptr, &outLen);
454     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
455     SoftBusFree(outData);
456     ret = DecryptInner(&list, AUTH_LINK_TYPE_WIFI, &inDataInfo, &outData, nullptr);
457     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
458     SoftBusFree(outData);
459     inDataInfo.inLen = 0;
460     ret = DecryptInner(&list, AUTH_LINK_TYPE_WIFI, &inDataInfo, &outData, &outLen);
461     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
462     SoftBusFree(outData);
463     ListInit(&list);
464     ret = AddSessionKey(&list, TO_INT32(authSeq), &sessionKey, AUTH_LINK_TYPE_WIFI, false);
465     EXPECT_TRUE(ret == SOFTBUS_OK);
466     inDataInfo.inLen = CRYPT_DATA_LEN;
467     ret = DecryptInner(&list, AUTH_LINK_TYPE_WIFI, &inDataInfo, &outData, &outLen);
468     EXPECT_TRUE(ret == SOFTBUS_DECRYPT_ERR);
469     SoftBusFree(outData);
470 }
471 
472 /*
473  * @tc.name: POST_DEVICEID_MESSAGE_Test_001
474  * @tc.desc: post deviceId message test
475  * @tc.type: FUNC
476  * @tc.require:
477  */
478 HWTEST_F(AuthTest, POST_DEVICEID_MESSAGE_Test_001, TestSize.Level1)
479 {
480     int64_t authSeq = 0;
481     int64_t errAuthSeq = -1;
482     const AuthSessionInfo info = { 0 };
483     int32_t ret;
484 
485     ret = PostDeviceIdMessage(errAuthSeq, &info);
486     EXPECT_TRUE(ret != SOFTBUS_OK);
487     ret = PostDeviceIdMessage(authSeq, &info);
488     EXPECT_TRUE(ret != SOFTBUS_OK);
489 }
490 
491 /*
492  * @tc.name: POST_DEVICE_INFO_MESSAGE_Test_001
493  * @tc.desc: post device info message test
494  * @tc.type: FUNC
495  * @tc.require:
496  */
497 HWTEST_F(AuthTest, POST_DEVICE_INFO_MESSAGE_Test_001, TestSize.Level1)
498 {
499     int64_t authSeq = 0;
500     int64_t errAuthSeq = -1;
501     const AuthSessionInfo info = { 0 };
502     int32_t ret;
503 
504     ret = PostDeviceInfoMessage(errAuthSeq, &info);
505     EXPECT_TRUE(ret != SOFTBUS_OK);
506     ret = PostDeviceInfoMessage(authSeq, &info);
507     EXPECT_TRUE(ret != SOFTBUS_OK);
508 }
509 
510 /*
511  * @tc.name: PROCESS_DEVICE_INFO_MESSAGE_Test_001
512  * @tc.desc: process device info message test
513  * @tc.type: FUNC
514  * @tc.require:
515  */
516 HWTEST_F(AuthTest, PROCESS_DEVICE_INFO_MESSAGE_Test_001, TestSize.Level1)
517 {
518     int64_t authSeq = 0;
519     AuthSessionInfo info = { 0 };
520     const uint8_t data[TEST_DATA_LEN] = { 0 };
521     uint32_t len = TEST_DATA_LEN;
522 
523     int32_t ret = ProcessDeviceInfoMessage(authSeq, &info, data, len);
524     EXPECT_TRUE(ret == SOFTBUS_DECRYPT_ERR);
525     info.normalizedType = NORMALIZED_SUPPORT;
526     ret = ProcessDeviceInfoMessage(authSeq, &info, data, len);
527     EXPECT_TRUE(ret == SOFTBUS_DECRYPT_ERR);
528     info.normalizedType = NORMALIZED_KEY_ERROR;
529     ret = ProcessDeviceInfoMessage(authSeq, &info, data, len);
530     EXPECT_TRUE(ret == SOFTBUS_DECRYPT_ERR);
531 }
532 
533 /*
534  * @tc.name: POST_CLOSE_ACK_MESSAGE_Test_001
535  * @tc.desc: post close ack message test
536  * @tc.type: FUNC
537  * @tc.require:
538  */
539 HWTEST_F(AuthTest, POST_CLOSE_ACK_MESSAGE_Test_001, TestSize.Level1)
540 {
541     int64_t authSeq = 0;
542     int64_t errAuthSeq = -1;
543     const AuthSessionInfo info = { 0 };
544     int32_t ret;
545 
546     ret = PostDeviceInfoMessage(errAuthSeq, &info);
547     EXPECT_TRUE(ret != SOFTBUS_OK);
548     ret = PostDeviceInfoMessage(authSeq, &info);
549     EXPECT_TRUE(ret != SOFTBUS_OK);
550 }
551 
552 /*
553  * @tc.name: POST_HICHAIN_AUTH_MESSAGE_Test_001
554  * @tc.desc: post hichain auth message test
555  * @tc.type: FUNC
556  * @tc.require:
557  */
558 HWTEST_F(AuthTest, POST_HICHAIN_AUTH_MESSAGE_Test_001, TestSize.Level1)
559 {
560     int64_t authSeq = 0;
561     const AuthSessionInfo info = { 0 };
562     const uint8_t data[TEST_DATA_LEN] = { 0 };
563     uint32_t len = TEST_DATA_LEN;
564 
565     int32_t ret = PostHichainAuthMessage(authSeq, &info, data, len);
566     EXPECT_TRUE(ret != SOFTBUS_OK);
567 }
568 
569 /*
570  * @tc.name: POST_DEVICE_MESSAGE_Test_001
571  * @tc.desc: post device message test
572  * @tc.type: FUNC
573  * @tc.require:
574  */
575 HWTEST_F(AuthTest, POST_DEVICE_MESSAGE_Test_001, TestSize.Level1)
576 {
577     AuthManager auth = { 0 };
578     int32_t flagRelay = 1;
579     DeviceMessageParse messageParse = { CODE_VERIFY_DEVICE, DEFAULT_FREQ_CYCLE };
580     InitSessionKeyList(&auth.sessionKeyList);
581     int32_t ret = PostDeviceMessage(&auth, flagRelay, AUTH_LINK_TYPE_WIFI, &messageParse);
582     EXPECT_TRUE(ret == SOFTBUS_ENCRYPT_ERR);
583     messageParse.messageType = CODE_TCP_KEEPALIVE;
584     ret = PostDeviceMessage(&auth, flagRelay, AUTH_LINK_TYPE_WIFI, &messageParse);
585     EXPECT_TRUE(ret == SOFTBUS_ENCRYPT_ERR);
586 }
587 
588 /*
589  * @tc.name: POST_DEVICE_MESSAGE_Test_002
590  * @tc.desc: post device message test
591  * @tc.type: FUNC
592  * @tc.require:
593  */
594 HWTEST_F(AuthTest, POST_DEVICE_MESSAGE_Test_002, TestSize.Level1)
595 {
596     const AuthManager *auth = nullptr;
597     AuthManager authManager;
598     int32_t flagRelay = 1;
599     int32_t type = 0;
600     DeviceMessageParse messageParse = { CODE_VERIFY_DEVICE, DEFAULT_FREQ_CYCLE };
601     (void)memset_s(&authManager, sizeof(AuthManager), 0, sizeof(AuthManager));
602     int32_t ret = PostDeviceMessage(auth, flagRelay, AUTH_LINK_TYPE_WIFI, &messageParse);
603     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
604     ret = PostDeviceMessage(&authManager, flagRelay, AuthLinkType(type), nullptr);
605     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
606     ret = PostDeviceMessage(&authManager, flagRelay, AuthLinkType(type), &messageParse);
607     EXPECT_TRUE(ret == SOFTBUS_ERR);
608     type = LINK_TYPE;
609     ret = PostDeviceMessage(&authManager, flagRelay, AuthLinkType(type), &messageParse);
610     EXPECT_TRUE(ret == SOFTBUS_ERR);
611 }
612 
613 /*
614  * @tc.name: START_SOCKET_LISTENING_Test_001
615  * @tc.desc: start socket listening test
616  * @tc.type: FUNC
617  * @tc.require:
618  */
619 HWTEST_F(AuthTest, START_SOCKET_LISTENING_Test_001, TestSize.Level1)
620 {
621     LocalListenerInfo info = {
622         .type = CONNECT_TCP,
623         .socketOption = {
624             .addr = "192.168.12.1",
625             .port = 22,
626             .moduleId = AUTH,
627             .protocol = LNN_PROTOCOL_IP,
628         },
629     };
630     int32_t ret = StartSocketListening(AUTH, &info);
631     EXPECT_TRUE(ret == SOFTBUS_ERR);
632 }
633 
634 /*
635  * @tc.name: SOCKET_CONNECT_DEVICE_Test_001
636  * @tc.desc: socket connect device test
637  * @tc.type: FUNC
638  * @tc.require:
639  */
640 HWTEST_F(AuthTest, SOCKET_CONNECT_DEVICE_Test_001, TestSize.Level1)
641 {
642     const char *ip = "***.***.**.*";
643     int32_t port = 22;
644     bool isBlockMode = true;
645 
646     int32_t ret = SocketConnectDevice(ip, port, isBlockMode);
647     EXPECT_TRUE(ret == AUTH_INVALID_FD);
648 }
649 
650 /*
651  * @tc.name: SOCKER_POST_BYTES_Test_001
652  * @tc.desc: socket post bytes test
653  * @tc.type: FUNC
654  * @tc.require:
655  */
656 HWTEST_F(AuthTest, SOCKER_POST_BYTES_Test_001, TestSize.Level1)
657 {
658     int32_t fd = 1;
659     const AuthDataHead head = { 0 };
660     const uint8_t data[TEST_DATA_LEN] = { 0 };
661 
662     int32_t ret = SocketPostBytes(fd, &head, data);
663     EXPECT_TRUE(ret == SOFTBUS_ERR);
664 }
665 
666 /*
667  * @tc.name: SOCKER_GET_CONN_INFO_Test_001
668  * @tc.desc: socket get conn info test
669  * @tc.type: FUNC
670  * @tc.require:
671  */
672 HWTEST_F(AuthTest, SOCKER_GET_CONN_INFO_Test_001, TestSize.Level1)
673 {
674     int32_t fd = 1;
675     AuthConnInfo connInfo;
676     bool isServer = true;
677 
678     (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
679     int32_t ret = SocketGetConnInfo(fd, &connInfo, &isServer);
680     EXPECT_TRUE(ret == SOFTBUS_ERR);
681 }
682 
683 /*
684  * @tc.name: REGAUTH_CHANNEL_LISTENER_Test_001
685  * @tc.desc: regauth channel listener test
686  * @tc.type: FUNC
687  * @tc.require:
688  */
689 HWTEST_F(AuthTest, REGAUTH_CHANNEL_LISTENER_Test_001, TestSize.Level1)
690 {
691     int32_t module = 0;
692     AuthChannelListener listener = { 0 };
693     int32_t ret;
694 
695     ret = RegAuthChannelListener(module, nullptr);
696     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
697     listener.onDataReceived = nullptr;
698     ret = RegAuthChannelListener(module, &listener);
699     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
700 }
701 
702 /*
703  * @tc.name: AUTH_OPRN_CHANNEL_Test_001
704  * @tc.desc: auth open channel test
705  * @tc.type: FUNC
706  * @tc.require:
707  */
708 HWTEST_F(AuthTest, AUTH_OPRN_CHANNEL_Test_001, TestSize.Level1)
709 {
710     const char *ip = "***.***.**.*";
711     int32_t port = 1;
712     int32_t ret;
713 
714     ret = AuthOpenChannel(nullptr, port);
715     EXPECT_TRUE(ret == INVALID_CHANNEL_ID);
716     port = 0;
717     ret = AuthOpenChannel(ip, port);
718     EXPECT_TRUE(ret == INVALID_CHANNEL_ID);
719 }
720 
721 /*
722  * @tc.name: AUTH_POST_CHANNEL_DATA_Test_001
723  * @tc.desc: auth post channel data test
724  * @tc.type: FUNC
725  * @tc.require:
726  */
727 HWTEST_F(AuthTest, AUTH_POST_CHANNEL_DATA_Test_001, TestSize.Level1)
728 {
729     int32_t channelId = -1;
730     const uint8_t testData[TEST_DATA_LEN] = { 0 };
731     AuthChannelData data = {
732         .module = 0,
733         .flag = 0,
734         .seq = 0,
735         .len = TEST_DATA_LEN,
736         .data = nullptr,
737     };
738     int32_t ret;
739 
740     ret = AuthPostChannelData(channelId, &data);
741     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
742     channelId = 0;
743     ret = AuthPostChannelData(channelId, nullptr);
744     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
745     data.len = 0;
746     ret = AuthPostChannelData(channelId, &data);
747     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
748     data.len = 0;
749     data.data = testData;
750     ret = AuthPostChannelData(channelId, &data);
751     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
752 }
753 
754 /*
755  * @tc.name: AUTH_MANAGER_SET_SESSION_KEY_Test_001
756  * @tc.desc: auth manager set session key test
757  * @tc.type: FUNC
758  * @tc.require:
759  */
760 HWTEST_F(AuthTest, AUTH_MANAGER_SET_SESSION_KEY_Test_001, TestSize.Level1)
761 {
762     int64_t authSeq = 0;
763     AuthSessionInfo info = { 0 };
764     const SessionKey sessionKey = { { 0 }, TEST_DATA_LEN };
765 
766     info.connInfo.type = AUTH_LINK_TYPE_BLE;
767     int32_t ret = AuthManagerSetSessionKey(authSeq, &info, &sessionKey, false, false);
768     EXPECT_TRUE(ret == SOFTBUS_OK);
769 }
770 
771 /*
772  * @tc.name: AUTH_MANAGER_GET_SESSION_KEY_Test_001
773  * @tc.desc: auth manager get session key test
774  * @tc.type: FUNC
775  * @tc.require:
776  */
777 HWTEST_F(AuthTest, AUTH_MANAGER_GET_SESSION_KEY_Test_001, TestSize.Level1)
778 {
779     int64_t authSeq = 0;
780     AuthSessionInfo info = { 0 };
781     SessionKey sessionKey = { { 0 }, TEST_DATA_LEN };
782 
783     info.connInfo.type = AUTH_LINK_TYPE_BLE;
784     int32_t ret = AuthManagerGetSessionKey(authSeq, &info, &sessionKey);
785     EXPECT_TRUE(ret == SOFTBUS_OK);
786 }
787 
788 /*
789  * @tc.name: REGAUTH_VERIFY_LISTENER_Test_001
790  * @tc.desc: regAuth verify listener test
791  * @tc.type: FUNC
792  * @tc.require:
793  */
794 HWTEST_F(AuthTest, REGAUTH_VERIFY_LISTENER_Test_001, TestSize.Level1)
795 {
796     int32_t ret = RegAuthVerifyListener(nullptr);
797     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
798 }
799 
800 /*
801  * @tc.name: AUTH_START_VERIFY_Test_001
802  * @tc.desc: auth start verify test
803  * @tc.type: FUNC
804  * @tc.require:
805  */
806 HWTEST_F(AuthTest, AUTH_START_VERIFY_Test_001, TestSize.Level1)
807 {
808     AuthConnInfo connInfo;
809     uint32_t requestId = 0;
810     const AuthVerifyCallback callback = { 0 };
811     int32_t ret;
812 
813     (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
814     connInfo.type = AUTH_LINK_TYPE_BLE;
815     ret = AuthStartVerify(nullptr, requestId, &callback, AUTH_MODULE_LNN, true);
816     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
817     ret = AuthStartVerify(&connInfo, requestId, nullptr, AUTH_MODULE_LNN, true);
818     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
819 }
820 
821 /*
822  * @tc.name: AUTH_START_CONN_VERIFY_Test_001
823  * @tc.desc: auth start conn verify test
824  * @tc.type: FUNC
825  * @tc.require:
826  */
827 HWTEST_F(AuthTest, AUTH_START_CONN_VERIFY_Test_001, TestSize.Level1)
828 {
829     AuthConnInfo connInfo;
830     uint32_t requestId = 0;
831     const AuthConnCallback callback = { 0 };
832     int32_t ret;
833 
834     (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
835     ret = AuthStartConnVerify(nullptr, requestId, &callback, AUTH_MODULE_LNN, true);
836     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
837     ret = AuthStartConnVerify(&connInfo, requestId, &callback, AUTH_MODULE_LNN, true);
838     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
839 }
840 
841 /*
842  * @tc.name: AUTH_FLUSH_DEVICE_Test_001
843  * @tc.desc: auth flush device test
844  * @tc.type: FUNC
845  * @tc.require:
846  */
847 HWTEST_F(AuthTest, AUTH_FLUSH_DEVICE_Test_001, TestSize.Level1)
848 {
849     char uuid[TEST_DATA_LEN] = "testdata";
850     int32_t ret;
851 
852     ret = AuthFlushDevice(nullptr);
853     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
854     uuid[0] = '\0';
855     ret = AuthFlushDevice(const_cast<const char *>(uuid));
856     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
857     uuid[0] = '1';
858     ret = AuthFlushDevice(const_cast<const char *>(uuid));
859     EXPECT_TRUE(ret == SOFTBUS_ERR);
860 }
861 
862 /*
863  * @tc.name: AUTH_SEND_KEEPALIVE_OPTION_Test_001
864  * @tc.desc: auth send keepalive test
865  * @tc.type: FUNC
866  * @tc.require:
867  */
868 HWTEST_F(AuthTest, AUTH_SEND_KEEPALIVE_OPTION_Test_001, TestSize.Level1)
869 {
870     char uuid[TEST_DATA_LEN] = "testdata";
871     int32_t time = 0;
872     int32_t ret;
873 
874     ret = AuthSendKeepaliveOption(nullptr, HIGH_FREQ_CYCLE);
875     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
876     ret = AuthSendKeepaliveOption(uuid, (ModeCycle)time);
877     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
878     uuid[0] = '\0';
879     ret = AuthSendKeepaliveOption(const_cast<const char *>(uuid), HIGH_FREQ_CYCLE);
880     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
881     uuid[0] = '1';
882     ret = AuthSendKeepaliveOption(const_cast<const char *>(uuid), HIGH_FREQ_CYCLE);
883     EXPECT_TRUE(ret == SOFTBUS_ERR);
884 }
885 
886 /*
887  * @tc.name: AUTH_DEVICE_GET_PREFER_CONN_INFO_Test_001
888  * @tc.desc: auth device get prefer conn info test
889  * @tc.type: FUNC
890  * @tc.require:
891  */
892 HWTEST_F(AuthTest, AUTH_DEVICE_GET_PREFER_CONN_INFO_Test_001, TestSize.Level1)
893 {
894     char uuid[TEST_DATA_LEN] = "testdata";
895     AuthConnInfo connInfo;
896     int32_t ret;
897 
898     (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
899     ret = AuthDeviceGetPreferConnInfo(nullptr, &connInfo);
900     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
901     uuid[0] = '\0';
902     ret = AuthDeviceGetPreferConnInfo(const_cast<const char *>(uuid), &connInfo);
903     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
904     uuid[0] = '1';
905     ret = AuthDeviceGetPreferConnInfo(const_cast<const char *>(uuid), nullptr);
906     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
907     ret = AuthDeviceGetPreferConnInfo(const_cast<const char *>(uuid), &connInfo);
908     EXPECT_TRUE(ret != SOFTBUS_INVALID_PARAM);
909 }
910 
911 /*
912  * @tc.name: AUTH_DEVICE_POST_TRANS_DATA_Test_001
913  * @tc.desc: auth device post trans data test
914  * @tc.type: FUNC
915  * @tc.require:
916  */
917 HWTEST_F(AuthTest, AUTH_DEVICE_POST_TRANS_DATA_Test_001, TestSize.Level1)
918 {
919     int64_t authId = 0;
920     AuthHandle authHandle = { .authId = authId, .type = AUTH_LINK_TYPE_BLE };
921     int32_t ret;
922     const AuthTransData dataInfo = { 0 };
923     AuthSessionInfo info;
924 
925     (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
926     info.isServer = true;
927     info.connInfo.type = AUTH_LINK_TYPE_BLE;
928 
929     AuthManager *auth = NewAuthManager(authId, &info);
930     EXPECT_TRUE(auth != nullptr);
931     ret = AuthDevicePostTransData(authHandle, nullptr);
932     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
933     ret = AuthDevicePostTransData(authHandle, &dataInfo);
934     EXPECT_TRUE(ret == SOFTBUS_ENCRYPT_ERR);
935     DelAuthManager(auth, AUTH_LINK_TYPE_MAX);
936 }
937 
938 /*
939  * @tc.name: AUTH_DEVICE_GET_ID_BY_CONN_INFO_Test_001
940  * @tc.desc: auth device get id by conn info test
941  * @tc.type: FUNC
942  * @tc.require:
943  */
944 HWTEST_F(AuthTest, AUTH_DEVICE_GET_ID_BY_CONN_INFO_Test_001, TestSize.Level1)
945 {
946     AuthConnInfo connInfo;
947     int64_t ret;
948 
949     (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
950     ret = AuthDeviceGetIdByConnInfo(nullptr, true);
951     EXPECT_TRUE(ret == AUTH_INVALID_ID);
952     connInfo.type = AUTH_LINK_TYPE_BLE;
953     ret = AuthDeviceGetIdByConnInfo(&connInfo, true);
954     EXPECT_TRUE(ret == AUTH_INVALID_ID);
955 }
956 
957 /*
958  * @tc.name: AUTH_DEVICE_GET_ID_BY_P2P_MAC_Test_001
959  * @tc.desc: auth device get id by p2p mac test
960  * @tc.type: FUNC
961  * @tc.require:
962  */
963 HWTEST_F(AuthTest, AUTH_DEVICE_GET_ID_BY_P2P_MAC_Test_001, TestSize.Level1)
964 {
965     AuthLinkType type = AUTH_LINK_TYPE_WIFI;
966     bool isServer = true;
967     int64_t ret;
968     ret = AuthDeviceGetIdByUuid(nullptr, type, isServer);
969     EXPECT_TRUE(ret == AUTH_INVALID_ID);
970     ret = AuthDeviceGetIdByUuid(P2P_MAC2, type, isServer);
971     EXPECT_TRUE(ret == AUTH_INVALID_ID);
972     ret = AuthDeviceGetIdByUuid(P2P_MAC, type, isServer);
973     EXPECT_TRUE(ret == AUTH_INVALID_ID);
974 }
975 
AuthOnDataReceived(AuthHandle authHandle,const AuthTransData * data)976 static void AuthOnDataReceived(AuthHandle authHandle, const AuthTransData *data)
977 {
978     (void)authHandle;
979     (void)data;
980 }
981 
AuthOnDisconnected(AuthHandle authHandle)982 static void AuthOnDisconnected(AuthHandle authHandle)
983 {
984     (void)authHandle;
985 }
986 
987 /*
988  * @tc.name: REGAUTH_TRANS_LISTENER_Test_001
989  * @tc.desc: regAuth trans listener test
990  * @tc.type: FUNC
991  * @tc.require:
992  */
993 HWTEST_F(AuthTest, REGAUTH_TRANS_LISTENER_Test_001, TestSize.Level1)
994 {
995     int32_t module = 0;
996     AuthTransListener listener = {
997         .onDataReceived = AuthOnDataReceived,
998         .onDisconnected = AuthOnDisconnected,
999         .onException = NULL,
1000     };
1001     int32_t ret;
1002     ret = RegAuthTransListener(module, nullptr);
1003     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1004     ret = RegAuthTransListener(module, &listener);
1005     EXPECT_TRUE(ret != SOFTBUS_OK);
1006     RegAuthTransListener(MODULE_UDP_INFO, &listener);
1007     UnregAuthTransListener(MODULE_UDP_INFO);
1008 }
1009 
1010 /*
1011  * @tc.name: AUTH_GET_PREFER_CONNINFO_Test_001
1012  * @tc.desc: auth get prefer connInfo test
1013  * @tc.type: FUNC
1014  * @tc.require:
1015  */
1016 HWTEST_F(AuthTest, AUTH_GET_PREFER_CONNINFO_Test_001, TestSize.Level1)
1017 {
1018     char uuid[TEST_DATA_LEN] = "testdata";
1019     AuthConnInfo connInfo;
1020     int32_t ret;
1021 
1022     (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
1023     ret = AuthGetPreferConnInfo(nullptr, &connInfo, false);
1024     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1025     ret = AuthGetPreferConnInfo(nullptr, &connInfo, true);
1026     EXPECT_TRUE(ret != SOFTBUS_OK);
1027     ret = AuthGetPreferConnInfo(const_cast<const char *>(uuid), nullptr, false);
1028     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1029     ret = AuthGetPreferConnInfo(const_cast<const char *>(uuid), nullptr, true);
1030     EXPECT_TRUE(ret != SOFTBUS_OK);
1031     uuid[0] = '\0';
1032     ret = AuthGetPreferConnInfo(const_cast<const char *>(uuid), &connInfo, false);
1033     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1034     ret = AuthGetPreferConnInfo(const_cast<const char *>(uuid), &connInfo, true);
1035     EXPECT_TRUE(ret != SOFTBUS_OK);
1036     uuid[0] = '1';
1037     ret = AuthGetPreferConnInfo(const_cast<const char *>(uuid), &connInfo, false);
1038     EXPECT_TRUE(ret != SOFTBUS_OK);
1039     ret = AuthGetPreferConnInfo(const_cast<const char *>(uuid), &connInfo, true);
1040     EXPECT_TRUE(ret != SOFTBUS_OK);
1041 }
1042 
1043 /*
1044  * @tc.name: AUTH_OPEN_CONN_Test_001
1045  * @tc.desc: auth open conn test
1046  * @tc.type: FUNC
1047  * @tc.require:
1048  */
1049 HWTEST_F(AuthTest, AUTH_OPEN_CONN_Test_001, TestSize.Level1)
1050 {
1051     AuthConnInfo info;
1052     uint32_t requestId = 0;
1053     const AuthConnCallback callback = { 0 };
1054     int32_t ret;
1055 
1056     (void)memset_s(&info, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
1057     ret = AuthOpenConn(nullptr, requestId, &callback, false);
1058     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1059     ret = AuthOpenConn(&info, requestId, nullptr, false);
1060     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1061     ret = AuthOpenConn(nullptr, requestId, nullptr, false);
1062     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1063     ret = AuthOpenConn(&info, requestId, &callback, false);
1064     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1065     info.type = AUTH_LINK_TYPE_WIFI;
1066     ret = AuthOpenConn(&info, requestId, &callback, false);
1067     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1068     ret = AuthOpenConn(&info, requestId, &callback, true);
1069     EXPECT_TRUE(ret != SOFTBUS_OK);
1070 }
1071 
1072 /*
1073  * @tc.name: AUTH_POST_TRANS_DATA_Test_001
1074  * @tc.desc: auth post trans data test
1075  * @tc.type: FUNC
1076  * @tc.require:
1077  */
1078 HWTEST_F(AuthTest, AUTH_POST_TRANS_DATA_Test_001, TestSize.Level1)
1079 {
1080     int64_t authId = 0;
1081     int32_t ret;
1082     const AuthTransData dataInfo = { 0 };
1083     AuthSessionInfo info;
1084 
1085     (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
1086     info.isServer = true;
1087     info.connInfo.type = AUTH_LINK_TYPE_BLE;
1088     AuthHandle authHandle = { .authId = 0, .type = info.connInfo.type };
1089 
1090     AuthManager *auth = NewAuthManager(authId, &info);
1091     EXPECT_TRUE(auth != nullptr);
1092     ret = AuthPostTransData(authHandle, nullptr);
1093     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1094     ret = AuthPostTransData(authHandle, &dataInfo);
1095     EXPECT_TRUE(ret == SOFTBUS_ENCRYPT_ERR);
1096     AuthCloseConn(authHandle);
1097     DelAuthManager(auth, AUTH_LINK_TYPE_MAX);
1098 }
1099 
1100 /*
1101  * @tc.name: REG_GROUP_CHANGE_LISTENER_Test_001
1102  * @tc.desc: Reg Group Change Listener test
1103  * @tc.type: FUNC
1104  * @tc.require:
1105  */
1106 HWTEST_F(AuthTest, REG_GROUP_CHANGE_LISTENER_Test_001, TestSize.Level1)
1107 {
1108     int32_t ret = RegGroupChangeListener(nullptr);
1109     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1110 
1111     const GroupChangeListener listener = { 0 };
1112     ret = RegGroupChangeListener(&listener);
1113     EXPECT_TRUE(ret == SOFTBUS_OK);
1114     UnregGroupChangeListener();
1115 }
1116 
1117 /*
1118  * @tc.name: AUTH_GET_ID_BY_CONN_INFO_Test_001
1119  * @tc.desc: auth get id by conn info test
1120  * @tc.type: FUNC
1121  * @tc.require:
1122  */
1123 HWTEST_F(AuthTest, AUTH_GET_ID_BY_CONN_INFO_Test_001, TestSize.Level1)
1124 {
1125     int64_t ret;
1126 
1127     ret = AuthGetIdByConnInfo(nullptr, true, false);
1128     EXPECT_TRUE(ret == AUTH_INVALID_ID);
1129     ret = AuthGetIdByConnInfo(nullptr, true, true);
1130     EXPECT_TRUE(ret != SOFTBUS_OK);
1131 }
1132 
1133 /*
1134  * @tc.name: AUTH_GET_ID_BY_P2P_MAC_Test_001
1135  * @tc.desc: auth get id by p2p mac test
1136  * @tc.type: FUNC
1137  * @tc.require:
1138  */
1139 HWTEST_F(AuthTest, AUTH_GET_ID_BY_P2P_MAC_Test_001, TestSize.Level1)
1140 {
1141     AuthLinkType type;
1142     int64_t ret;
1143 
1144     type = AUTH_LINK_TYPE_BR;
1145     ret = AuthGetIdByUuid(nullptr, type, true, false);
1146     EXPECT_TRUE(ret == AUTH_INVALID_ID);
1147     ret = AuthGetIdByUuid(nullptr, type, true, true);
1148     EXPECT_TRUE(ret != SOFTBUS_OK);
1149     ret = AuthGetIdByUuid(UUID_TEST, type, true, false);
1150     EXPECT_TRUE(ret == AUTH_INVALID_ID);
1151     ret = AuthGetIdByUuid(UUID_TEST, type, true, true);
1152     EXPECT_TRUE(ret != SOFTBUS_OK);
1153     ret = AuthGetIdByUuid(UUID_TEST2, type, true, false);
1154     EXPECT_TRUE(ret == AUTH_INVALID_ID);
1155     ret = AuthGetIdByUuid(UUID_TEST2, type, true, true);
1156     EXPECT_TRUE(ret != SOFTBUS_OK);
1157 }
1158 
1159 /*
1160  * @tc.name: AUTH_ENCRYPT_Test_001
1161  * @tc.desc: auth encrypt test
1162  * @tc.type: FUNC
1163  * @tc.require:
1164  */
1165 HWTEST_F(AuthTest, AUTH_ENCRYPT_Test_001, TestSize.Level1)
1166 {
1167     int64_t authId = 0;
1168     const uint8_t inData[CRYPT_DATA_LEN] = { 0 };
1169     uint32_t inLen = CRYPT_DATA_LEN;
1170     uint8_t outData[CRYPT_DATA_LEN] = { 0 };
1171     uint32_t outLen = CRYPT_DATA_LEN;
1172     uint32_t errLen = 0;
1173     int32_t ret;
1174     AuthSessionInfo info;
1175 
1176     (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
1177     info.isServer = true;
1178     info.connInfo.type = AUTH_LINK_TYPE_BLE;
1179     AuthHandle authHandle = { .authId = authId, .type = AUTH_LINK_TYPE_WIFI };
1180     AuthManager *auth = NewAuthManager(authId, &info);
1181     EXPECT_TRUE(auth != nullptr);
1182     ret = AuthEncrypt(&authHandle, nullptr, inLen, outData, &outLen);
1183     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1184     ret = AuthEncrypt(&authHandle, inData, inLen, nullptr, &outLen);
1185     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1186     ret = AuthEncrypt(&authHandle, inData, inLen, outData, nullptr);
1187     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1188     ret = AuthEncrypt(&authHandle, inData, errLen, outData, &outLen);
1189     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1190     ret = AuthEncrypt(&authHandle, inData, inLen, outData, &errLen);
1191     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1192     DelAuthManager(auth, AUTH_LINK_TYPE_MAX);
1193 }
1194 
1195 /*
1196  * @tc.name: AUTH_DECRYPT_Test_001
1197  * @tc.desc: auth eecrypt test
1198  * @tc.type: FUNC
1199  * @tc.require:
1200  */
1201 HWTEST_F(AuthTest, AUTH_DECRYPT_Test_001, TestSize.Level1)
1202 {
1203     int64_t authId = 0;
1204     const uint8_t inData[CRYPT_DATA_LEN] = { 0 };
1205     uint32_t inLen = CRYPT_DATA_LEN;
1206     uint8_t outData[CRYPT_DATA_LEN] = { 0 };
1207     uint32_t outLen = CRYPT_DATA_LEN;
1208     uint32_t errLen = 0;
1209     int32_t ret;
1210     AuthSessionInfo info;
1211 
1212     (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
1213     info.isServer = true;
1214     info.connInfo.type = AUTH_LINK_TYPE_BLE;
1215     AuthHandle authHandle = { .authId = authId, .type = AUTH_LINK_TYPE_WIFI };
1216     AuthManager *auth = NewAuthManager(authId, &info);
1217     EXPECT_TRUE(auth != nullptr);
1218     ret = AuthDecrypt(&authHandle, nullptr, inLen, outData, &outLen);
1219     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1220     ret = AuthDecrypt(&authHandle, inData, inLen, nullptr, &outLen);
1221     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1222     ret = AuthDecrypt(&authHandle, inData, inLen, outData, nullptr);
1223     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1224     ret = AuthDecrypt(&authHandle, inData, errLen, outData, &outLen);
1225     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1226     ret = AuthDecrypt(&authHandle, inData, inLen, outData, &errLen);
1227     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1228     ret = AuthDecrypt(&authHandle, inData, inLen, outData, &outLen);
1229     EXPECT_TRUE(ret == SOFTBUS_ENCRYPT_ERR);
1230     DelAuthManager(auth, AUTH_LINK_TYPE_MAX);
1231 }
1232 
1233 /*
1234  * @tc.name: AUTH_SET_P2P_MAC_Test_001
1235  * @tc.desc: auth set p2p mac test
1236  * @tc.type: FUNC
1237  * @tc.require:
1238  */
1239 HWTEST_F(AuthTest, AUTH_SET_P2P_MAC_Test_001, TestSize.Level1)
1240 {
1241     int64_t authId = 0;
1242     int32_t ret;
1243     AuthSessionInfo info;
1244 
1245     (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
1246     info.isServer = true;
1247     info.connInfo.type = AUTH_LINK_TYPE_BLE;
1248 
1249     AuthManager *auth = NewAuthManager(authId, &info);
1250     EXPECT_TRUE(auth != nullptr);
1251     ret = AuthSetP2pMac(authId, nullptr);
1252     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1253     ret = AuthSetP2pMac(authId, P2P_MAC);
1254     EXPECT_TRUE(ret != SOFTBUS_INVALID_PARAM);
1255     ret = AuthSetP2pMac(authId, P2P_MAC2);
1256     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1257     DelAuthManager(auth, AUTH_LINK_TYPE_MAX);
1258 }
1259 
1260 /*
1261  * @tc.name: AUTH_GET_CONN_INFO_Test_001
1262  * @tc.desc: auth get conn info test
1263  * @tc.type: FUNC
1264  * @tc.require:
1265  */
1266 HWTEST_F(AuthTest, AUTH_GET_CONN_INFO_Test_001, TestSize.Level1)
1267 {
1268     int64_t authId = 0;
1269     int32_t ret;
1270     AuthSessionInfo info;
1271 
1272     (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
1273     info.isServer = true;
1274     info.connInfo.type = AUTH_LINK_TYPE_BLE;
1275     AuthHandle authHandle = { .authId = authId, .type = info.connInfo.type };
1276     AuthManager *auth = NewAuthManager(authId, &info);
1277     EXPECT_TRUE(auth != nullptr);
1278     ret = AuthGetConnInfo(authHandle, nullptr);
1279     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1280     DelAuthManager(auth, AUTH_LINK_TYPE_MAX);
1281 }
1282 
1283 /*
1284  * @tc.name: AUTH_GET_SERVER_SIDE_Test_001
1285  * @tc.desc: auth get server side test
1286  * @tc.type: FUNC
1287  * @tc.require:
1288  */
1289 HWTEST_F(AuthTest, AUTH_GET_SERVER_SIDE_Test_001, TestSize.Level1)
1290 {
1291     int64_t authId = 0;
1292     int32_t ret;
1293     AuthSessionInfo info;
1294 
1295     (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
1296     info.isServer = true;
1297     info.connInfo.type = AUTH_LINK_TYPE_BLE;
1298 
1299     AuthManager *auth = NewAuthManager(authId, &info);
1300     EXPECT_TRUE(auth != nullptr);
1301     ret = AuthGetServerSide(authId, nullptr);
1302     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1303     DelAuthManager(auth, AUTH_LINK_TYPE_MAX);
1304 }
1305 
1306 /*
1307  * @tc.name: AUTH_GET_META_TYPE_Test_001
1308  * @tc.desc: auth get meta type test
1309  * @tc.type: FUNC
1310  * @tc.require:
1311  */
1312 HWTEST_F(AuthTest, AUTH_GET_META_TYPE_Test_001, TestSize.Level1)
1313 {
1314     int64_t authId = 0;
1315     bool isMetaAuth = true;
1316     int32_t ret;
1317 
1318     ret = AuthGetMetaType(authId, nullptr);
1319     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1320     ret = AuthGetMetaType(authId, &isMetaAuth);
1321     EXPECT_TRUE(ret == SOFTBUS_OK);
1322 }
1323 
1324 /*
1325  * @tc.name: AUTH_GET_DEVICE_UUID_Test_001
1326  * @tc.desc: auth get device uuid test
1327  * @tc.type: FUNC
1328  * @tc.require:
1329  */
1330 HWTEST_F(AuthTest, AUTH_GET_DEVICE_UUID_Test_001, TestSize.Level1)
1331 {
1332     int64_t authId = 0;
1333     int32_t ret;
1334     char uuid[TEST_DATA_LEN] = "testdata";
1335     uint16_t size = TEST_DATA_LEN;
1336     AuthSessionInfo info;
1337 
1338     (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
1339     (void)strcpy_s(info.udid, TEST_DATA_LEN, uuid);
1340     info.isServer = true;
1341     info.connInfo.type = AUTH_LINK_TYPE_BLE;
1342 
1343     AuthManager *auth = NewAuthManager(authId, &info);
1344     EXPECT_TRUE(auth != nullptr);
1345     ret = AuthGetDeviceUuid(authId, nullptr, size);
1346     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1347     ret = AuthGetDeviceUuid(authId, uuid, size);
1348     EXPECT_TRUE(ret == SOFTBUS_OK);
1349     DelAuthManager(auth, AUTH_LINK_TYPE_MAX);
1350 }
1351 
1352 /*
1353  * @tc.name: AUTH_GET_VERSION_Test_001
1354  * @tc.desc: auth get version test
1355  * @tc.type: FUNC
1356  * @tc.require:
1357  */
1358 HWTEST_F(AuthTest, AUTH_GET_VERSION_Test_001, TestSize.Level1)
1359 {
1360     int64_t authId = 0;
1361     int32_t ret;
1362     SoftBusVersion version;
1363     AuthSessionInfo info;
1364     version = SOFTBUS_OLD_V1;
1365 
1366     (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
1367     info.isServer = true;
1368     info.connInfo.type = AUTH_LINK_TYPE_BLE;
1369 
1370     AuthManager *auth = NewAuthManager(authId, &info);
1371     EXPECT_TRUE(auth != nullptr);
1372     ret = AuthGetVersion(authId, nullptr);
1373     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1374     ret = AuthGetVersion(authId, &version);
1375     EXPECT_TRUE(ret == SOFTBUS_OK);
1376     DelAuthManager(auth, 0);
1377     DelAuthManager(auth, AUTH_LINK_TYPE_MAX + 1);
1378     DelAuthManager(auth, AUTH_LINK_TYPE_MAX);
1379 }
1380 
1381 /*
1382  * @tc.name: AUTH_INIT_Test_001
1383  * @tc.desc: auth init test
1384  * @tc.type: FUNC
1385  * @tc.require:
1386  */
1387 HWTEST_F(AuthTest, AUTH_INIT_Test_001, TestSize.Level1)
1388 {
1389     int32_t ret;
1390 
1391     ret = AuthInit();
1392     EXPECT_TRUE(ret == SOFTBUS_ERR);
1393     AuthDeinit();
1394 }
1395 
AuthOnDataReceivedTest(AuthHandle authHandle,const AuthDataHead * head,const uint8_t * data,uint32_t len)1396 static void AuthOnDataReceivedTest(AuthHandle authHandle, const AuthDataHead *head, const uint8_t *data, uint32_t len)
1397 {
1398     (void)authHandle;
1399     (void)head;
1400     (void)data;
1401     (void)len;
1402 }
1403 
AuthOnDisconnectedTest(AuthHandle authHandle)1404 static void AuthOnDisconnectedTest(AuthHandle authHandle)
1405 {
1406     (void)authHandle;
1407 }
1408 
1409 /*
1410  * @tc.name: AUTH_INIT_Test_001
1411  * @tc.desc: auth init test
1412  * @tc.type: FUNC
1413  * @tc.require:
1414  */
1415 HWTEST_F(AuthTest, AUTH_DEVICE_INIT_Test_001, TestSize.Level1)
1416 {
1417     int32_t ret;
1418     AuthTransCallback callBack = {
1419         .onDataReceived = AuthOnDataReceivedTest,
1420         .onDisconnected = AuthOnDisconnectedTest,
1421         .onException = NULL,
1422     };
1423     ret = AuthDeviceInit(&callBack);
1424     EXPECT_TRUE(ret == SOFTBUS_ERR);
1425     ret = AuthDeviceInit(nullptr);
1426     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1427 }
1428 
1429 /*
1430  * @tc.name: POST_AUTH_EVENT_INIT_Test_001
1431  * @tc.desc: post suth event test
1432  * @tc.type: FUNC
1433  * @tc.require:
1434  */
1435 HWTEST_F(AuthTest, POST_AUTH_EVENT_INIT_Test_001, TestSize.Level1)
1436 {
1437     EventHandler handler = { 0 };
1438     const void *obj = "testdata";
1439     uint32_t size = TEST_DATA_LEN;
1440     uint64_t delayMs = 0;
1441     int32_t ret;
1442 
1443     ret = PostAuthEvent(EVENT_CONNECT_CMD, handler, obj, size, delayMs);
1444     EXPECT_TRUE(ret == SOFTBUS_NO_INIT);
1445 }
1446 
1447 /*
1448  * @tc.name: COMPARE_CONN_INFO_Test_001
1449  * @tc.desc: compare conn info test
1450  * @tc.type: FUNC
1451  * @tc.require:
1452  */
1453 HWTEST_F(AuthTest, COMPARE_CONN_INFO_Test_001, TestSize.Level1)
1454 {
1455     AuthConnInfo info1;
1456     AuthConnInfo info2;
1457     bool ret;
1458 
1459     (void)memset_s(&info1, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
1460     (void)memset_s(&info2, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
1461     info1.type = AUTH_LINK_TYPE_WIFI;
1462     info2.type = AUTH_LINK_TYPE_WIFI;
1463     ret = CompareConnInfo(&info1, &info2, false);
1464     EXPECT_TRUE(ret == true);
1465     info1.type = AUTH_LINK_TYPE_BR;
1466     info2.type = AUTH_LINK_TYPE_BR;
1467     ret = CompareConnInfo(&info1, &info2, false);
1468     EXPECT_TRUE(ret == true);
1469     info1.type = AUTH_LINK_TYPE_BLE;
1470     info2.type = AUTH_LINK_TYPE_BLE;
1471     ret = CompareConnInfo(&info1, &info2, false);
1472     EXPECT_TRUE(ret == true);
1473     info1.type = AUTH_LINK_TYPE_P2P;
1474     info2.type = AUTH_LINK_TYPE_P2P;
1475     ret = CompareConnInfo(&info1, &info2, false);
1476     EXPECT_TRUE(ret == true);
1477 }
1478 
1479 /*
1480  * @tc.name: CONVERT_TO_CONNECT_OPTION_Test_001
1481  * @tc.desc: convert to connect option test
1482  * @tc.type: FUNC
1483  * @tc.require:
1484  */
1485 HWTEST_F(AuthTest, CONVERT_TO_CONNECT_OPTION_Test_001, TestSize.Level1)
1486 {
1487     AuthConnInfo connInfo;
1488     ConnectOption option;
1489     int32_t ret;
1490 
1491     (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
1492     (void)memset_s(&option, sizeof(ConnectOption), 0, sizeof(ConnectOption));
1493     connInfo.type = AUTH_LINK_TYPE_BR;
1494     ret = ConvertToConnectOption(&connInfo, &option);
1495     EXPECT_TRUE(ret == SOFTBUS_OK);
1496     connInfo.type = AUTH_LINK_TYPE_BLE;
1497     ret = ConvertToConnectOption(&connInfo, &option);
1498     EXPECT_TRUE(ret == SOFTBUS_OK);
1499     connInfo.type = AUTH_LINK_TYPE_P2P;
1500     ret = ConvertToConnectOption(&connInfo, &option);
1501     EXPECT_TRUE(ret == SOFTBUS_OK);
1502 }
1503 
1504 /*
1505  * @tc.name: CONVERT_TO_AUTH_CONNINFO_Test_001
1506  * @tc.desc: convert to auth connInfo test
1507  * @tc.type: FUNC
1508  * @tc.require:
1509  */
1510 HWTEST_F(AuthTest, CONVERT_TO_AUTH_CONNINFO_Test_001, TestSize.Level1)
1511 {
1512     ConnectionInfo info;
1513     AuthConnInfo connInfo;
1514     int32_t ret;
1515 
1516     (void)memset_s(&info, sizeof(ConnectionInfo), 0, sizeof(ConnectionInfo));
1517     (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
1518     info.type = CONNECT_TCP;
1519     info.socketInfo.protocol = LNN_PROTOCOL_IP;
1520     ret = ConvertToAuthConnInfo(&info, &connInfo);
1521     EXPECT_TRUE(ret == SOFTBUS_OK);
1522     info.socketInfo.protocol = LNN_PROTOCOL_BR;
1523     ret = ConvertToAuthConnInfo(&info, &connInfo);
1524     EXPECT_TRUE(ret == SOFTBUS_ERR);
1525     info.type = CONNECT_BR;
1526     ret = ConvertToAuthConnInfo(&info, &connInfo);
1527     EXPECT_TRUE(ret == SOFTBUS_OK);
1528     info.type = CONNECT_BLE;
1529     ret = ConvertToAuthConnInfo(&info, &connInfo);
1530     EXPECT_TRUE(ret == SOFTBUS_OK);
1531 }
1532 
1533 /*
1534  * @tc.name: AUTH_CONN_INIT_Test_001
1535  * @tc.desc: auth conn init test
1536  * @tc.type: FUNC
1537  * @tc.require:
1538  */
1539 HWTEST_F(AuthTest, AUTH_CONN_INIT_Test_001, TestSize.Level1)
1540 {
1541     AuthConnListener listener;
1542     (void)memset_s(&listener, sizeof(AuthConnListener), 0, sizeof(AuthConnListener));
1543     int32_t ret = AuthConnInit(nullptr);
1544     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1545     ret = AuthConnInit(&listener);
1546     EXPECT_TRUE(ret != SOFTBUS_OK);
1547 }
1548 
1549 /*
1550  * @tc.name: CONNECT_AUTH_DEVICE_Test_001
1551  * @tc.desc: connect auth device test
1552  * @tc.type: FUNC
1553  * @tc.require:
1554  */
1555 HWTEST_F(AuthTest, CONNECT_AUTH_DEVICE_Test_001, TestSize.Level1)
1556 {
1557     uint32_t requestId = 123;
1558     AuthConnInfo connInfo;
1559     ConnSideType sideType = CONN_SIDE_SERVER;
1560     int32_t ret;
1561 
1562     (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
1563     connInfo.type = AUTH_LINK_TYPE_WIFI;
1564     ret = ConnectAuthDevice(requestId, &connInfo, sideType);
1565     EXPECT_TRUE(ret != SOFTBUS_INVALID_PARAM);
1566     connInfo.type = AUTH_LINK_TYPE_P2P;
1567     ret = ConnectAuthDevice(requestId, &connInfo, sideType);
1568     EXPECT_TRUE(ret != SOFTBUS_INVALID_PARAM);
1569 }
1570 
1571 /*
1572  * @tc.name: AUTH_START_LISTENING_Test_001
1573  * @tc.desc: auth start listening test
1574  * @tc.type: FUNC
1575  * @tc.require:
1576  */
1577 HWTEST_F(AuthTest, AUTH_START_LISTENING_Test_001, TestSize.Level1)
1578 {
1579     const char *ip = "***.***.**.*";
1580     int32_t port = 22;
1581     int32_t ret;
1582 
1583     ret = AuthStartListening(AUTH_LINK_TYPE_WIFI, nullptr, port);
1584     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1585     ret = AuthStartListening(AUTH_LINK_TYPE_WIFI, ip, port);
1586     EXPECT_TRUE(ret != SOFTBUS_INVALID_PARAM);
1587     ret = AuthStartListening(AUTH_LINK_TYPE_P2P, ip, port);
1588     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM || ret == SOFTBUS_CONN_MANAGER_TYPE_NOT_SUPPORT);
1589 }
1590 
1591 /*
1592  * @tc.name: FIND_AUTH_REQUEST_BY_CONN_INFO_Test_001
1593  * @tc.desc: Find Auth Request By Conn Info test
1594  * @tc.type: FUNC
1595  * @tc.require:
1596  */
1597 HWTEST_F(AuthTest, FIND_AUTH_REQUEST_BY_CONN_INFO_Test_001, TestSize.Level1)
1598 {
1599     AuthConnInfo *authConnInfo = nullptr;
1600     AuthRequest *request = nullptr;
1601     AuthConnInfo authConnInfoValue;
1602     AuthRequest requestValue;
1603     (void)memset_s(&authConnInfoValue, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
1604     (void)memset_s(&requestValue, sizeof(AuthRequest), 0, sizeof(AuthRequest));
1605     int32_t ret = FindAuthRequestByConnInfo(authConnInfo, request);
1606     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1607     ret = FindAuthRequestByConnInfo(&authConnInfoValue, request);
1608     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1609 }
1610 
1611 /*
1612  * @tc.name: CHECK_VERIFY_CALLBACK_Test_001
1613  * @tc.desc: Check Verify Callback test
1614  * @tc.type: FUNC
1615  * @tc.require:
1616  */
1617 HWTEST_F(AuthTest, CHECK_VERIFY_CALLBACK_Test_001, TestSize.Level1)
1618 {
1619     bool ret = CheckVerifyCallback(LnnGetVerifyCallback());
1620     EXPECT_TRUE(ret == true);
1621     ret = CheckVerifyCallback(nullptr);
1622     EXPECT_TRUE(ret == false);
1623     AuthVerifyCallback verifyCb = {
1624         .onVerifyPassed = nullptr,
1625         .onVerifyFailed = nullptr,
1626     };
1627     ret = CheckVerifyCallback(&verifyCb);
1628     EXPECT_TRUE(ret == false);
1629 
1630     uint32_t requestId = 0;
1631     AuthHandle authHandle = { .authId = 0, .type = AUTH_LINK_TYPE_MAX };
1632     NodeInfo nodeinfo;
1633     (void)memset_s(&nodeinfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
1634     PerformVerifyCallback(requestId, SOFTBUS_INVALID_PARAM, authHandle, &nodeinfo);
1635     authHandle.type = 0;
1636     PerformVerifyCallback(requestId, SOFTBUS_INVALID_PARAM, authHandle, &nodeinfo);
1637     authHandle.type = AUTH_LINK_TYPE_WIFI;
1638     PerformVerifyCallback(requestId, SOFTBUS_INVALID_PARAM, authHandle, &nodeinfo);
1639 }
1640 
OnConnOpenedTest(uint32_t requestId,AuthHandle authHandle)1641 static void OnConnOpenedTest(uint32_t requestId, AuthHandle authHandle)
1642 {
1643     AUTH_LOGI(AUTH_TEST, "requestId=%{public}d, authId=%{public}" PRId64, requestId, authHandle.authId);
1644 }
1645 
OnConnOpenFailedTest(uint32_t requestId,int32_t reason)1646 static void OnConnOpenFailedTest(uint32_t requestId, int32_t reason)
1647 {
1648     AUTH_LOGI(AUTH_TEST, "requestId=%{public}d, reason=%{public}d", requestId, reason);
1649 }
1650 /*
1651  * @tc.name: CHECK_AUTH_CONN_CALLBACK_Test_001
1652  * @tc.desc: Check Auth Conn Callback test
1653  * @tc.type: FUNC
1654  * @tc.require:
1655  */
1656 HWTEST_F(AuthTest, CHECK_AUTH_CONN_CALLBACK_Test_001, TestSize.Level1)
1657 {
1658     AuthConnCallback cb = {
1659         .onConnOpened = OnConnOpenedTest,
1660         .onConnOpenFailed = OnConnOpenFailedTest,
1661     };
1662     AuthConnCallback connCb = {
1663         .onConnOpened = nullptr,
1664         .onConnOpenFailed = nullptr,
1665     };
1666     bool ret = CheckAuthConnCallback(nullptr);
1667     EXPECT_TRUE(ret == false);
1668     ret = CheckAuthConnCallback(&connCb);
1669     EXPECT_TRUE(ret == false);
1670     ret = CheckAuthConnCallback(&cb);
1671     EXPECT_TRUE(ret == true);
1672 
1673     AuthRequest request = {0};
1674     uint32_t requestId = 0;
1675     int64_t authId = 0;
1676     PerformAuthConnCallback(requestId, SOFTBUS_OK, authId);
1677     request.connCb = cb;
1678     int32_t result = AddAuthRequest(&request);
1679     EXPECT_EQ(result, SOFTBUS_OK);
1680     PerformAuthConnCallback(requestId, SOFTBUS_OK, authId);
1681 }
1682 
1683 /*
1684  * @tc.name: AUTH_SESSION_START_AUTH_Test_001
1685  * @tc.desc: Auth Session Start Auth test
1686  * @tc.type: FUNC
1687  * @tc.require:
1688  */
1689 HWTEST_F(AuthTest, AUTH_SESSION_START_AUTH_Test_001, TestSize.Level1)
1690 {
1691     uint32_t requestId = 0;
1692     uint64_t connId = 0;
1693     AuthConnInfo *connInfo = nullptr;
1694     AuthParam authInfo = {
1695         .authSeq = GenSeq(false),
1696         .requestId = requestId,
1697         .connId = connId,
1698         .isServer = false,
1699         .isFastAuth = true,
1700     };
1701     int32_t ret = AuthSessionStartAuth(&authInfo, connInfo);
1702     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1703     AuthConnInfo authConnInfo;
1704     authConnInfo.type = AUTH_LINK_TYPE_WIFI;
1705     constexpr char NODE1_BR_MAC[] = "12345TTU";
1706     const char *ip = "***.***.**.*";
1707     (void)strcpy_s(authConnInfo.info.brInfo.brMac, BT_MAC_LEN, NODE1_BR_MAC);
1708     authConnInfo.info.ipInfo.port = 20;
1709     authConnInfo.info.ipInfo.authId = 1024;
1710     (void)strcpy_s(authConnInfo.info.ipInfo.ip, IP_LEN, ip);
1711     ret = AuthSessionStartAuth(&authInfo, &authConnInfo);
1712     EXPECT_TRUE(ret == SOFTBUS_LOCK_ERR);
1713 }
1714 
1715 /*
1716  * @tc.name: AUTH_SESSION_PROCESS_DEV_ID_DATA_Test_001
1717  * @tc.desc: Auth Session Process Dev Id Data test
1718  * @tc.type: FUNC
1719  * @tc.require:
1720  */
1721 HWTEST_F(AuthTest, AUTH_SESSION_PROCESS_DEV_ID_DATA_Test_001, TestSize.Level1)
1722 {
1723     int64_t authSeq = 0;
1724     uint8_t *data = nullptr;
1725     uint32_t len = 0;
1726     int32_t ret = AuthSessionProcessDevIdData(authSeq, data, len);
1727     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1728 }
1729 
1730 /*
1731  * @tc.name: AUTH_SESSION_SAVE_SESSION_KEY_Test_001
1732  * @tc.desc: Auth Session Save Session Key test
1733  * @tc.type: FUNC
1734  * @tc.require:
1735  */
1736 HWTEST_F(AuthTest, AUTH_SESSION_SAVE_SESSION_KEY_Test_001, TestSize.Level1)
1737 {
1738     int64_t authSeq = 0;
1739     uint8_t *key = nullptr;
1740     uint32_t len = 0;
1741     int32_t ret = AuthSessionSaveSessionKey(authSeq, key, len);
1742     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1743 }
1744 
1745 /*
1746  * @tc.name: AUTH_SESSION_PROCESS_DEV_INFO_DATA_Test_001
1747  * @tc.desc: Auth Session Process Dev Info Data test
1748  * @tc.type: FUNC
1749  * @tc.require:
1750  */
1751 HWTEST_F(AuthTest, AUTH_SESSION_PROCESS_DEV_INFO_DATA_Test_001, TestSize.Level1)
1752 {
1753     int64_t authSeq = 0;
1754     const uint8_t *data = nullptr;
1755     uint32_t len = 0;
1756     int32_t ret = AuthSessionProcessDevInfoData(authSeq, data, len);
1757     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1758 }
1759 
1760 /*
1761  * @tc.name: AUTH_SESSION_PROCESS_DEV_INFO_DATA_BY_CONN_ID_Test_001
1762  * @tc.desc: Auth Session Process Dev Info Data By Conn Id test
1763  * @tc.type: FUNC
1764  * @tc.require:
1765  */
1766 HWTEST_F(AuthTest, AUTH_SESSION_PROCESS_DEV_INFO_DATA_BY_CONN_ID_Test_001, TestSize.Level1)
1767 {
1768     int64_t connId = 0;
1769     bool isServer = false;
1770     const uint8_t *data = nullptr;
1771     uint32_t len = 0;
1772     int32_t ret = AuthSessionProcessDevInfoDataByConnId(connId, isServer, data, len);
1773     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1774 }
1775 
1776 /*
1777  * @tc.name: AUTH_SESSION_PROCESS_CLOSE_ACK_BY_CONN_ID_Test_001
1778  * @tc.desc: Auth Session Process Close Ack By Conn Id test
1779  * @tc.type: FUNC
1780  * @tc.require:
1781  */
1782 HWTEST_F(AuthTest, AUTH_SESSION_PROCESS_CLOSE_ACK_BY_CONN_ID_Test_001, TestSize.Level1)
1783 {
1784     int64_t connId = 0;
1785     bool isServer = false;
1786     const uint8_t *data = nullptr;
1787     uint32_t len = 0;
1788     int32_t ret = AuthSessionProcessCloseAckByConnId(connId, isServer, data, len);
1789     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1790 }
1791 
1792 /*
1793  * @tc.name: DUP_SESSION_KEY_LIST_Test_001
1794  * @tc.desc: Dup Session Key List test
1795  * @tc.type: FUNC
1796  * @tc.require:
1797  */
1798 HWTEST_F(AuthTest, DUP_SESSION_KEY_LIST_Test_001, TestSize.Level1)
1799 {
1800     SessionKeyList *srcList = nullptr;
1801     SessionKeyList *dstList = nullptr;
1802     int32_t ret = DupSessionKeyList(srcList, dstList);
1803     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1804 }
1805 
1806 /*
1807  * @tc.name: HAS_SESSION_KEY_Test_001
1808  * @tc.desc: Has Session Key test
1809  * @tc.type: FUNC
1810  * @tc.require:
1811  */
1812 HWTEST_F(AuthTest, HAS_SESSION_KEY_Test_001, TestSize.Level1)
1813 {
1814     SessionKeyList *list = nullptr;
1815     int32_t ret = HasSessionKey(list);
1816     EXPECT_TRUE(ret == false);
1817 }
1818 
1819 /*
1820  * @tc.name: ADD_SESSION_KEY_Test_001
1821  * @tc.desc: Add Session Key test
1822  * @tc.type: FUNC
1823  * @tc.require:
1824  */
1825 HWTEST_F(AuthTest, ADD_SESSION_KEY_Test_001, TestSize.Level1)
1826 {
1827     SessionKeyList *list = nullptr;
1828     int32_t index = 0;
1829     SessionKey *key = nullptr;
1830     SessionKey keyValue;
1831     SessionKeyList listValue;
1832     int32_t ret = AddSessionKey(list, index, key, AUTH_LINK_TYPE_WIFI, false);
1833     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1834     (void)memset_s(&keyValue, sizeof(SessionKey), 0, sizeof(SessionKey));
1835     (void)memset_s(&listValue, sizeof(SessionKeyList), 0, sizeof(SessionKeyList));
1836     ListInit(&listValue);
1837     ret = AddSessionKey(&listValue, index, &keyValue, AUTH_LINK_TYPE_WIFI, false);
1838     EXPECT_TRUE(ret == SOFTBUS_OK);
1839 }
1840 
1841 /*
1842  * @tc.name: ENCRYPT_DATA_Test_001
1843  * @tc.desc: Encrypt Data test
1844  * @tc.type: FUNC
1845  * @tc.require:
1846  */
1847 HWTEST_F(AuthTest, ENCRYPT_DATA_Test_001, TestSize.Level1)
1848 {
1849     SessionKeyList *list = nullptr;
1850     SessionKeyList listValue;
1851     (void)memset_s(&listValue, sizeof(SessionKeyList), 0, sizeof(SessionKeyList));
1852     uint8_t indata[TEST_DATA_LEN] = "1234";
1853     uint8_t outData[TEST_DATA_LEN];
1854     uint32_t outLen = TEST_DATA_LEN;
1855     InDataInfo inDataInfo = { .inData = indata, .inLen = TEST_DATA_LEN };
1856     int32_t ret = EncryptData(list, AUTH_LINK_TYPE_WIFI, &inDataInfo, outData, &outLen);
1857     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1858 }
1859 
1860 /*
1861  * @tc.name: DECRYPT_DATA_Test_001
1862  * @tc.desc: Decrypt Data test
1863  * @tc.type: FUNC
1864  * @tc.require:
1865  */
1866 HWTEST_F(AuthTest, DECRYPT_DATA_Test_001, TestSize.Level1)
1867 {
1868     SessionKeyList *list = nullptr;
1869     uint8_t indata[TEST_DATA_LEN] = "1234";
1870     uint8_t outData[TEST_DATA_LEN];
1871     uint32_t outLen = TEST_DATA_LEN;
1872     InDataInfo inDataInfo = { .inData = indata, .inLen = ENCRYPT_OVER_HEAD_LEN_TEST + 1 };
1873     int32_t ret = DecryptData(list, AUTH_LINK_TYPE_WIFI, &inDataInfo, outData, &outLen);
1874     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1875 }
1876 
1877 /*
1878  * @tc.name: UNPACK_DEVICE_INFO_MESSAGE_Test_001
1879  * @tc.desc: Unpack Device Info Message test
1880  * @tc.type: FUNC
1881  * @tc.require:
1882  */
1883 HWTEST_F(AuthTest, UNPACK_DEVICE_INFO_MESSAGE_Test_001, TestSize.Level1)
1884 {
1885     const char *msg = "";
1886     int32_t linkType = 1;
1887     SoftBusVersion version = SOFTBUS_OLD_V1;
1888     NodeInfo nodeInfo;
1889     AuthSessionInfo info;
1890     (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
1891     (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
1892     bool isMetaAuth = false;
1893     DevInfoData devInfo = {msg, 0, linkType, version};
1894     int32_t ret = UnpackDeviceInfoMessage(&devInfo, &nodeInfo, isMetaAuth, &info);
1895     EXPECT_TRUE(ret == SOFTBUS_ERR);
1896 }
1897 
1898 /*
1899  * @tc.name: POST_DEVICE_ID_MESSAGE_Test_001
1900  * @tc.desc: Post Device Id Message test
1901  * @tc.type: FUNC
1902  * @tc.require:
1903  */
1904 HWTEST_F(AuthTest, POST_DEVICE_ID_MESSAGE_Test_001, TestSize.Level1)
1905 {
1906     AuthSessionInfo *info = nullptr;
1907     AuthSessionInfo infoValue;
1908     (void)memset_s(&infoValue, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
1909     int32_t ret = PostDeviceIdMessage(GenSeq(false), info);
1910     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1911     ret = PostDeviceIdMessage(GenSeq(false), &infoValue);
1912     EXPECT_TRUE(ret != SOFTBUS_OK);
1913 }
1914 
1915 /*
1916  * @tc.name: PROCESS_DEVICE_ID_MESSAGE_Test_001
1917  * @tc.desc: Process Device Id Message test
1918  * @tc.type: FUNC
1919  * @tc.require:
1920  */
1921 HWTEST_F(AuthTest, PROCESS_DEVICE_ID_MESSAGE_Test_001, TestSize.Level1)
1922 {
1923     AuthSessionInfo *info = nullptr;
1924     AuthSessionInfo infoValue;
1925     (void)memset_s(&infoValue, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
1926     uint8_t data[TEST_DATA_LEN] = "123";
1927     int32_t ret = ProcessDeviceIdMessage(info, data, sizeof(data));
1928     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1929     ret = ProcessDeviceIdMessage(&infoValue, data, sizeof(data));
1930     EXPECT_TRUE(ret != SOFTBUS_OK);
1931 }
1932 
1933 /*
1934  * @tc.name: SET_SOCKET_CALLBACK_Test_001
1935  * @tc.desc: Set Socket Callback test
1936  * @tc.type: FUNC
1937  * @tc.require:
1938  */
1939 HWTEST_F(AuthTest, SET_SOCKET_CALLBACK_Test_001, TestSize.Level1)
1940 {
1941     const SocketCallback *cb = nullptr;
1942     int32_t ret = SetSocketCallback(cb);
1943     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1944 }
1945 
1946 /*
1947  * @tc.name: SOCKET_POST_BYTES_Test_001
1948  * @tc.desc: Socket Post Bytes test
1949  * @tc.type: FUNC
1950  * @tc.require:
1951  */
1952 HWTEST_F(AuthTest, SOCKET_POST_BYTES_Test_001, TestSize.Level1)
1953 {
1954     int32_t fd = 0;
1955     const AuthDataHead *head = NULL;
1956     const uint8_t *data = NULL;
1957     int32_t ret = SocketPostBytes(fd, head, data);
1958     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1959     AuthDataHead headValue;
1960     uint8_t dataValue[TEST_DATA_LEN] = "123";
1961     (void)memset_s(&headValue, sizeof(AuthDataHead), 0, sizeof(AuthDataHead));
1962     ret = SocketPostBytes(fd, &headValue, dataValue);
1963     EXPECT_TRUE(ret == SOFTBUS_ERR);
1964 }
1965 
1966 /*
1967  * @tc.name: SOCKET_GET_CONN_INFO_Test_001
1968  * @tc.desc: Socket Get Conn Info test
1969  * @tc.type: FUNC
1970  * @tc.require:
1971  */
1972 HWTEST_F(AuthTest, SOCKET_GET_CONN_INFO_Test_001, TestSize.Level1)
1973 {
1974     int32_t fd = 0;
1975     AuthConnInfo *connInfo = NULL;
1976     bool isServer = false;
1977     int32_t ret = SocketGetConnInfo(fd, connInfo, &isServer);
1978     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1979     AuthConnInfo connInfoValue;
1980     (void)memset_s(&connInfoValue, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
1981     ret = SocketGetConnInfo(fd, &connInfoValue, &isServer);
1982     EXPECT_TRUE(ret == SOFTBUS_ERR);
1983 }
1984 
1985 /*
1986  * @tc.name: REG_AUTH_CHANNEL_LISTENER_Test_001
1987  * @tc.desc: Reg Auth Channel Listener test
1988  * @tc.type: FUNC
1989  * @tc.require:
1990  */
1991 HWTEST_F(AuthTest, REG_AUTH_CHANNEL_LISTENER_Test_001, TestSize.Level1)
1992 {
1993     int32_t module = MODULE_AUTH_CHANNEL;
1994     const AuthChannelListener *listener = nullptr;
1995     int32_t ret = RegAuthChannelListener(module, listener);
1996     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1997 }
1998 
1999 /*
2000  * @tc.name: AUTH_OPEN_CHANNEL_Test_001
2001  * @tc.desc: Auth Open Channel test
2002  * @tc.type: FUNC
2003  * @tc.require:
2004  */
2005 HWTEST_F(AuthTest, AUTH_OPEN_CHANNEL_Test_001, TestSize.Level1)
2006 {
2007     char *ip = nullptr;
2008     char ipValue[32] = "0";
2009     int32_t port = 22;
2010     int32_t ret = AuthOpenChannel(ip, port);
2011     EXPECT_TRUE(ret == INVALID_CHANNEL_ID);
2012     ret = AuthOpenChannel(ipValue, port);
2013     EXPECT_TRUE(ret == INVALID_CHANNEL_ID);
2014 }
2015 
2016 /*
2017  * @tc.name: AUTH_GET_DECRYPT_SIZE_Test_001
2018  * @tc.desc: Auth Get Decrypt Size test
2019  * @tc.type: FUNC
2020  * @tc.require:
2021  */
2022 HWTEST_F(AuthTest, AUTH_GET_DECRYPT_SIZE_Test_001, TestSize.Level1)
2023 {
2024     uint32_t inLen = OVERHEAD_LEN;
2025     uint32_t ret = AuthGetDecryptSize(inLen);
2026     EXPECT_TRUE(ret == OVERHEAD_LEN);
2027     inLen = OVERHEAD_LEN + 1;
2028     ret = AuthGetDecryptSize(inLen);
2029     EXPECT_TRUE(ret == (inLen - OVERHEAD_LEN));
2030 }
2031 
2032 /*
2033  * @tc.name: NOTIFY_TRANS_DATA_RECEIVED_Test_001
2034  * @tc.desc: Notify Trans Data Received test
2035  * @tc.type: FUNC
2036  * @tc.require:
2037  */
2038 HWTEST_F(AuthTest, NOTIFY_TRANS_DATA_RECEIVED_Test_001, TestSize.Level1)
2039 {
2040     AuthTransListener listener = {
2041         .onDataReceived = AuthOnDataReceived,
2042         .onDisconnected = AuthOnDisconnected,
2043         .onException = NULL,
2044     };
2045     int32_t ret;
2046     ret = RegAuthTransListener(MODULE_UDP_INFO, &listener);
2047     EXPECT_TRUE(ret == SOFTBUS_OK);
2048     AuthHandle authHandle = { .authId = 0, .type = AUTH_LINK_TYPE_WIFI };
2049     AuthDataHead head = {
2050         .dataType = 0,
2051         .module = MODULE_UDP_INFO,
2052         .seq = 0,
2053         .flag = 0,
2054         .len = 20,
2055     };
2056     const char *data = "1111222233334444";
2057     uint32_t len = 0;
2058     NotifyTransDataReceived(authHandle, &head, reinterpret_cast<const uint8_t *>(data), len);
2059     NotifyTransDisconnected(authHandle);
2060     NotifyTransException(authHandle, SOFTBUS_INVALID_PARAM);
2061     UnregAuthTransListener(MODULE_UDP_INFO);
2062 }
2063 
2064 /*
2065  * @tc.name: AUTH_ON_CONNECT_EVENT_Test_001
2066  * @tc.desc: Auth On Connect Event test
2067  * @tc.type: FUNC
2068  * @tc.require:
2069  */
2070 HWTEST_F(AuthTest, AUTH_ON_CONNECT_EVENT_Test_001, TestSize.Level1)
2071 {
2072     ListenerModule module = AUTH;
2073     int32_t cfd = 0;
2074     ConnectOption option;
2075     (void)memset_s(&option, sizeof(ConnectOption), 0, sizeof(ConnectOption));
2076     int32_t ret = OnConnectEvent(module, cfd, &option);
2077     EXPECT_TRUE(ret == SOFTBUS_ERR);
2078 }
2079 
2080 /*
2081  * @tc.name: GetLatestAvailableSessionKeyTimeTest
2082  * @tc.desc: set and get session key available sessionKey
2083  * @tc.type: FUNC
2084  * @tc.require:
2085  */
2086 HWTEST_F(AuthTest, AUTH_SET_AND_SET_SESSIONKEY_AVAILABLE_Test_001, TestSize.Level1)
2087 {
2088     SessionKeyList list = { 0 };
2089     SessionKey sessionKey = { { 0 }, TEST_DATA_LEN };
2090     int32_t index = 0;
2091     ListInit(&list);
2092     int32_t ret = AddSessionKey(&list, index, &sessionKey, AUTH_LINK_TYPE_WIFI, false);
2093     EXPECT_TRUE(ret == SOFTBUS_OK);
2094     uint64_t time = GetLatestAvailableSessionKeyTime(&list, AUTH_LINK_TYPE_WIFI);
2095     EXPECT_TRUE(time == 0);
2096     ret = SetSessionKeyAvailable(&list, 0);
2097     EXPECT_TRUE(ret == SOFTBUS_OK);
2098     time = GetLatestAvailableSessionKeyTime(&list, AUTH_LINK_TYPE_WIFI);
2099     EXPECT_TRUE(time != 0);
2100     DestroySessionKeyList(&list);
2101 }
2102 
2103 /*
2104  * @tc.name: AUTH_SET_TCP_KEEPALIVE_OPTION_Test_001
2105  * @tc.desc: Auth Set Tcp Keepalive option test
2106  * @tc.type: FUNC
2107  * @tc.require:
2108  */
2109 HWTEST_F(AuthTest, AUTH_SET_TCP_KEEPALIVE_OPTION_Test_001, TestSize.Level1)
2110 {
2111     int32_t fd = -1;
2112     int32_t cycle = 0;
2113 
2114     int32_t ret = AuthSetTcpKeepaliveOption(fd, HIGH_FREQ_CYCLE);
2115     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
2116     fd = 0;
2117     ret = AuthSetTcpKeepaliveOption(fd, HIGH_FREQ_CYCLE);
2118     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
2119     fd = 1;
2120     ret = AuthSetTcpKeepaliveOption(fd, (ModeCycle)cycle);
2121     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
2122     cycle = KEEPALIVE_TIME;
2123     ret = AuthSetTcpKeepaliveOption(fd, (ModeCycle)cycle);
2124     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
2125 }
2126 
2127 /*
2128  * @tc.name: AUTH_SET_TCP_KEEPALIVE_OPTION_Test_002
2129  * @tc.desc: Auth Set Tcp Keepalive option test
2130  * @tc.type: FUNC
2131  * @tc.require:
2132  */
2133 HWTEST_F(AuthTest, AUTH_SET_TCP_KEEPALIVE_OPTION_Test_002, TestSize.Level1)
2134 {
2135     int32_t fd = 1;
2136 
2137     int32_t ret = AuthSetTcpKeepaliveOption(fd, HIGH_FREQ_CYCLE);
2138     EXPECT_TRUE(ret == SOFTBUS_ADAPTER_ERR);
2139     ret = AuthSetTcpKeepaliveOption(fd, MID_FREQ_CYCLE);
2140     EXPECT_TRUE(ret == SOFTBUS_ADAPTER_ERR);
2141     ret = AuthSetTcpKeepaliveOption(fd, LOW_FREQ_CYCLE);
2142     EXPECT_TRUE(ret == SOFTBUS_ADAPTER_ERR);
2143     ret = AuthSetTcpKeepaliveOption(fd, DEFAULT_FREQ_CYCLE);
2144     EXPECT_TRUE(ret == SOFTBUS_ADAPTER_ERR);
2145 }
2146 
2147 /*
2148  * @tc.name: AUTH_SET_TCP_KEEPALIVE_OPTION_Test_003
2149  * @tc.desc: Auth Set Tcp Keepalive option test
2150  * @tc.type: FUNC
2151  * @tc.require:
2152  */
2153 HWTEST_F(AuthTest, AUTH_SET_TCP_KEEPALIVE_OPTION_Test_003, TestSize.Level1)
2154 {
2155     const SocketInterface *tcp = GetTcpProtocol();
2156     ASSERT_NE(tcp, nullptr);
2157 
2158     int port = CLIENT_PORT;
2159     char ipAddress[] = "127.0.0.1";
2160     LocalListenerInfo info = {};
2161     info.type = CONNECT_TCP;
2162     info.socketOption.port = port;
2163     info.socketOption.moduleId = DIRECT_CHANNEL_SERVER_WIFI;
2164     info.socketOption.protocol = LNN_PROTOCOL_IP;
2165     (void)strcpy_s(info.socketOption.addr, sizeof(info.socketOption.addr), ipAddress);
2166     int fd = tcp->OpenServerSocket(&info);
2167 
2168     int32_t ret = AuthSetTcpKeepaliveOption(fd, HIGH_FREQ_CYCLE);
2169     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
2170 }
2171 
2172 /*
2173  * @tc.name: GET_TCP_KEEPALIVE_OPTION_BY_CYCLE_Test_001
2174  * @tc.desc: Get Tcp Keepalive Option By Cycle test
2175  * @tc.type: FUNC
2176  * @tc.require:
2177  */
2178 HWTEST_F(AuthTest, GET_TCP_KEEPALIVE_OPTION_BY_CYCLE_Test_001, TestSize.Level1)
2179 {
2180     TcpKeepaliveOption tcpKeepaliveOption = { 0 };
2181 
2182     int32_t ret = GetTcpKeepaliveOptionByCycle(HIGH_FREQ_CYCLE, nullptr);
2183     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
2184     ret = GetTcpKeepaliveOptionByCycle((ModeCycle)tcpKeepaliveOption.keepaliveIdle, &tcpKeepaliveOption);
2185     EXPECT_TRUE(ret == SOFTBUS_ERR);
2186 
2187     ret = GetTcpKeepaliveOptionByCycle(HIGH_FREQ_CYCLE, &tcpKeepaliveOption);
2188     EXPECT_TRUE(ret == SOFTBUS_OK);
2189     ret = GetTcpKeepaliveOptionByCycle(MID_FREQ_CYCLE, &tcpKeepaliveOption);
2190     EXPECT_TRUE(ret == SOFTBUS_OK);
2191     ret = GetTcpKeepaliveOptionByCycle(LOW_FREQ_CYCLE, &tcpKeepaliveOption);
2192     EXPECT_TRUE(ret == SOFTBUS_OK);
2193     ret = GetTcpKeepaliveOptionByCycle(DEFAULT_FREQ_CYCLE, &tcpKeepaliveOption);
2194     EXPECT_TRUE(ret == SOFTBUS_OK);
2195 }
2196 
2197 /*
2198  * @tc.name: IS_ENHANCE_P2P_MODULE_ID_Test_001
2199  * @tc.desc: IsEnhanceP2pModuleId test
2200  * @tc.type: FUNC
2201  * @tc.require:
2202  */
2203 HWTEST_F(AuthTest, IS_ENHANCE_P2P_MODULE_ID_Test_001, TestSize.Level1)
2204 {
2205     EXPECT_EQ(IsEnhanceP2pModuleId(AUTH_ENHANCED_P2P_START), true);
2206     EXPECT_EQ(IsEnhanceP2pModuleId(DIRECT_CHANNEL_SERVER_P2P), false);
2207     EXPECT_EQ(IsEnhanceP2pModuleId(AUTH_P2P), false);
2208 }
2209 
2210 /*
2211  * @tc.name: AUTH_GET_CONNINFO_BY_TYPE_Test_001
2212  * @tc.desc: AuthGetConnInfoByType test
2213  * @tc.type: FUNC
2214  * @tc.require:
2215  */
2216 HWTEST_F(AuthTest, AUTH_GET_CONNINFO_BY_TYPE_Test_001, TestSize.Level1)
2217 {
2218     const char *uuid = "12345678";
2219     AuthConnInfo connInfo;
2220 
2221     (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
2222     int32_t ret = AuthGetConnInfoByType(uuid, AUTH_LINK_TYPE_WIFI, &connInfo, true);
2223     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2224     ret = AuthGetConnInfoByType(nullptr, AUTH_LINK_TYPE_WIFI, &connInfo, false);
2225     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2226 }
2227 } // namespace OHOS
2228