1 /*
2 * Copyright (c) 2022-2025 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_log.h"
22 #include "auth_tcp_connection.c"
23 #include "auth_tcp_connection.h"
24 #include "softbus_error_code.h"
25 #include "softbus_socket.h"
26
27 namespace OHOS {
28 using namespace testing::ext;
29 constexpr uint32_t TEST_DATA_LEN = 30;
30 const int32_t TEST_MAGIC = 1;
31 const int32_t TEST_MODULE = 2;
32 const int64_t TSET_SEQ = 3;
33 const int32_t TEST_FLAG = 4;
34 const uint32_t TEST_LEN = 5;
35 constexpr uint8_t PACK_DATA[AUTH_PKT_HEAD_LEN] = "123456ABCDEF";
36
37 class AuthTcpConnectionTest : public testing::Test {
38 public:
39 static void SetUpTestCase();
40 static void TearDownTestCase();
41 void SetUp();
42 void TearDown();
43 int32_t SetSocketPktHead(SocketPktHead *head);
44 static void OnWiFiConnected(ListenerModule module, int32_t fd, bool isClient);
45 static void OnWiFiDisconnected(ListenerModule module, int32_t fd);
46 static void OnWiFiDataReceived(ListenerModule module, int32_t fd, const AuthDataHead *head,
47 const uint8_t *data);
48 static void OnDataReceived(int32_t authId, const AuthChannelData *data);
49 static void OnDisconnect(int32_t authId);
50 static bool isOnWiFiConnectedSuccess;
51 static bool isOnWiFiDisconnectedSuccess;
52 static bool isOnWiFiDataReceivedSuccess;
53 static bool isOnDataReceivedSuccess;
54 static bool isOnDisconnectSuccess;
55 };
56
57 bool AuthTcpConnectionTest::isOnWiFiConnectedSuccess = false;
58 bool AuthTcpConnectionTest::isOnWiFiDisconnectedSuccess = false;
59 bool AuthTcpConnectionTest::isOnWiFiDataReceivedSuccess = false;
60 bool AuthTcpConnectionTest::isOnDataReceivedSuccess = false;
61 bool AuthTcpConnectionTest::isOnDisconnectSuccess = false;
62
SetUpTestCase()63 void AuthTcpConnectionTest::SetUpTestCase() { }
64
TearDownTestCase()65 void AuthTcpConnectionTest::TearDownTestCase() { }
66
SetUp()67 void AuthTcpConnectionTest::SetUp()
68 {
69 AUTH_LOGI(AUTH_TEST, "AuthTcpConnectionTest start.");
70 }
71
TearDown()72 void AuthTcpConnectionTest::TearDown() { }
73
SetSocketPktHead(SocketPktHead * head)74 int32_t AuthTcpConnectionTest::SetSocketPktHead(SocketPktHead *head)
75 {
76 if (head == nullptr) {
77 AUTH_LOGE(AUTH_TEST, "aclInfo is null.");
78 return SOFTBUS_INVALID_PARAM;
79 }
80 head->magic = TEST_MAGIC;
81 head->module = TEST_MODULE;
82 head->seq = TSET_SEQ;
83 head->flag = TEST_FLAG;
84 head->len = TEST_LEN;
85 return SOFTBUS_OK;
86 }
87
OnWiFiConnected(ListenerModule module,int32_t fd,bool isClient)88 void AuthTcpConnectionTest::OnWiFiConnected(ListenerModule module, int32_t fd, bool isClient)
89 {
90 AUTH_LOGI(AUTH_TEST, "OnWiFiConnected: fd=%{public}d, side=%{public}s", fd,
91 isClient ? "client" : "server(ignored)");
92 isOnWiFiConnectedSuccess = true;
93 }
94
OnWiFiDisconnected(ListenerModule module,int32_t fd)95 void AuthTcpConnectionTest::OnWiFiDisconnected(ListenerModule module, int32_t fd)
96 {
97 AUTH_LOGI(AUTH_TEST, "OnWiFiDisconnected: module=%{public}d, fd=%{public}d", module, fd);
98 isOnWiFiDisconnectedSuccess = true;
99 }
100
OnWiFiDataReceived(ListenerModule module,int32_t fd,const AuthDataHead * head,const uint8_t * data)101 void AuthTcpConnectionTest::OnWiFiDataReceived(ListenerModule module, int32_t fd,
102 const AuthDataHead *head, const uint8_t *data)
103 {
104 AUTH_LOGI(AUTH_TEST, "OnWiFiDataReceived: module=%{public}d, fd=%{public}d", module, fd);
105 isOnWiFiDataReceivedSuccess = true;
106 }
107
OnDataReceived(int32_t authId,const AuthChannelData * data)108 void AuthTcpConnectionTest::OnDataReceived(int32_t authId, const AuthChannelData *data)
109 {
110 AUTH_LOGI(AUTH_TEST, "OnDataReceived: authId=%{public}d", authId);
111 isOnDataReceivedSuccess = true;
112 }
113
OnDisconnect(int32_t authId)114 void AuthTcpConnectionTest::OnDisconnect(int32_t authId)
115 {
116 AUTH_LOGI(AUTH_TEST, "OnDisconnect: authId=%{public}d", authId);
117 isOnDisconnectSuccess = true;
118 }
119
120 /*
121 * @tc.name: PACK_SOCKET_PKT_TEST_001
122 * @tc.desc: pack socket pkt test
123 * @tc.type: FUNC
124 * @tc.require:
125 */
126 HWTEST_F(AuthTcpConnectionTest, PACK_SOCKET_PKT_TEST_001, TestSize.Level1)
127 {
128 SocketPktHead head;
129 int32_t ret = SetSocketPktHead(&head);
130 EXPECT_EQ(ret, SOFTBUS_OK);
131 const uint8_t data[AUTH_PKT_HEAD_LEN] = { 0 };
132 uint8_t buf[10] = { 0 };
133 uint32_t size = 1;
134 ret = PackSocketPkt(&head, data, buf, size);
135 EXPECT_EQ(ret, SOFTBUS_NO_ENOUGH_DATA);
136 }
137
138 /*
139 * @tc.name: UNPACK_SOCKET_PKT_TEST_001
140 * @tc.desc: unpack socket pkt test
141 * @tc.type: FUNC
142 * @tc.require:
143 */
144 HWTEST_F(AuthTcpConnectionTest, UNPACK_SOCKET_PKT_TEST_001, TestSize.Level1)
145 {
146 const uint8_t data[AUTH_PKT_HEAD_LEN] = { 0 };
147 uint32_t len = 1;
148 SocketPktHead head;
149 (void)memset_s(&head, sizeof(head), 0, sizeof(head));
150 int32_t ret = UnpackSocketPkt(data, len, &head);
151 EXPECT_EQ(ret, SOFTBUS_NO_ENOUGH_DATA);
152 len = AUTH_PKT_HEAD_LEN;
153 ret = UnpackSocketPkt(data, len, &head);
154 EXPECT_EQ(ret, SOFTBUS_OK);
155 }
156
157 /*
158 * @tc.name: NOTIFY_CONNECTED_TEST_001
159 * @tc.desc: notify connected.
160 * @tc.type: FUNC
161 * @tc.require:
162 */
163 HWTEST_F(AuthTcpConnectionTest, NOTIFY_CONNECTED_TEST_001, TestSize.Level1)
164 {
165 ListenerModule module = ListenerModule::LISTENER_MODULE_DYNAMIC_START;
166 int32_t fd = 1;
167 bool isClient = true;
168 isOnWiFiConnectedSuccess = false;
169 NotifyConnected(module, fd, isClient);
170 EXPECT_FALSE(isOnWiFiConnectedSuccess);
171
172 SocketCallback socketCb = {
173 .onConnected = OnWiFiConnected,
174 .onDisconnected = OnWiFiDisconnected,
175 .onDataReceived = OnWiFiDataReceived,
176 };
177 int32_t ret = SetSocketCallback(&socketCb);
178 EXPECT_EQ(ret, SOFTBUS_OK);
179 NotifyConnected(module, fd, isClient);
180 EXPECT_TRUE(isOnWiFiConnectedSuccess);
181 UnsetSocketCallback();
182 }
183
184 /*
185 * @tc.name: NOTIFY_DISCONNECTED_TEST_001
186 * @tc.desc: notify disconnected.
187 * @tc.type: FUNC
188 * @tc.require:
189 */
190 HWTEST_F(AuthTcpConnectionTest, NOTIFY_DISCONNECTED_TEST_001, TestSize.Level1)
191 {
192 ListenerModule module = ListenerModule::LISTENER_MODULE_DYNAMIC_START;
193 int32_t fd = 1;
194 isOnWiFiDisconnectedSuccess = false;
195 NotifyDisconnected(module, fd);
196 EXPECT_FALSE(isOnWiFiDisconnectedSuccess);
197
198 SocketCallback socketCb = {
199 .onConnected = OnWiFiConnected,
200 .onDisconnected = OnWiFiDisconnected,
201 .onDataReceived = OnWiFiDataReceived,
202 };
203 int32_t ret = SetSocketCallback(&socketCb);
204 EXPECT_EQ(ret, SOFTBUS_OK);
205 NotifyDisconnected(module, fd);
206 EXPECT_TRUE(isOnWiFiDisconnectedSuccess);
207 UnsetSocketCallback();
208 }
209
210 /*
211 * @tc.name: MODULE_TO_DATA_TYPE_TEST_001
212 * @tc.desc: module to data type test
213 * @tc.type: FUNC
214 * @tc.require:
215 */
216 HWTEST_F(AuthTcpConnectionTest, MODULE_TO_DATA_TYPE_TEST_001, TestSize.Level1)
217 {
218 int32_t module = MODULE_TRUST_ENGINE;
219 uint32_t ret = ModuleToDataType(module);
220 EXPECT_EQ(ret, DATA_TYPE_DEVICE_ID);
221 module = MODULE_AUTH_SDK;
222 ret = ModuleToDataType(module);
223 EXPECT_EQ(ret, DATA_TYPE_AUTH);
224 module = MODULE_AUTH_CONNECTION;
225 ret = ModuleToDataType(module);
226 EXPECT_EQ(ret, DATA_TYPE_DEVICE_INFO);
227 module = MODULE_AUTH_CANCEL;
228 ret = ModuleToDataType(module);
229 EXPECT_EQ(ret, DATA_TYPE_CANCEL_AUTH);
230 module = MODULE_MESSAGE_SERVICE;
231 ret = ModuleToDataType(module);
232 EXPECT_EQ(ret, DATA_TYPE_CONNECTION);
233 }
234
235 /*
236 * @tc.name: SESSION_NOTIFY_DATA_RECEIVED_TEST_001
237 * @tc.desc: Notice received the data.
238 * @tc.type: FUNC
239 * @tc.require:
240 */
241 HWTEST_F(AuthTcpConnectionTest, SESSION_NOTIFY_DATA_RECEIVED_TEST_001, TestSize.Level1)
242 {
243 uint8_t data[AUTH_PKT_HEAD_LEN] = { 0 };
244 uint32_t len = 1;
245 ListenerModule module = ListenerModule::LISTENER_MODULE_DYNAMIC_START;
246 int32_t fd = 1;
247 isOnWiFiDataReceivedSuccess = false;
248 SessionNotifyDataReceived(module, fd, len, data);
249 EXPECT_FALSE(isOnWiFiDataReceivedSuccess);
250
251 len = AUTH_PKT_HEAD_LEN;
252 ASSERT_TRUE(memcpy_s(data, AUTH_PKT_HEAD_LEN, PACK_DATA, sizeof(PACK_DATA)) == EOK);
253 SessionNotifyDataReceived(module, fd, len, data);
254 EXPECT_FALSE(isOnWiFiDataReceivedSuccess);
255
256 SocketCallback socketCb = {
257 .onConnected = OnWiFiConnected,
258 .onDisconnected = OnWiFiDisconnected,
259 .onDataReceived = OnWiFiDataReceived,
260 };
261 int32_t ret = SetSocketCallback(&socketCb);
262 EXPECT_EQ(ret, SOFTBUS_OK);
263 SessionNotifyDataReceived(module, fd, len, data);
264 EXPECT_TRUE(isOnWiFiDataReceivedSuccess);
265 UnsetSocketCallback();
266 }
267
268 /*
269 * @tc.name: SESSION_KEY_NOTIFY_DATA_RECEIVED_TEST_001
270 * @tc.desc: Notice received the data.
271 * @tc.type: FUNC
272 * @tc.require:
273 */
274 HWTEST_F(AuthTcpConnectionTest, SESSION_KEY_NOTIFY_DATA_RECEIVED_TEST_001, TestSize.Level1)
275 {
276 uint8_t data[AUTH_PKT_HEAD_LEN] = { 0 };
277 uint32_t len = 1;
278 ListenerModule module = ListenerModule::LISTENER_MODULE_DYNAMIC_START;
279 int32_t fd = 1;
280 isOnWiFiDataReceivedSuccess = false;
281 SessionKeyNotifyDataReceived(module, fd, len, data);
282 EXPECT_FALSE(isOnWiFiDataReceivedSuccess);
283
284 len = AUTH_PKT_HEAD_LEN;
285 SessionKeyNotifyDataReceived(module, fd, len, data);
286 EXPECT_FALSE(isOnWiFiDataReceivedSuccess);
287
288 SocketCallback socketCb = {
289 .onConnected = OnWiFiConnected,
290 .onDisconnected = OnWiFiDisconnected,
291 .onDataReceived = OnWiFiDataReceived,
292 };
293 int32_t ret = SetSocketCallback(&socketCb);
294 EXPECT_EQ(ret, SOFTBUS_OK);
295 SessionKeyNotifyDataReceived(module, fd, len, data);
296 EXPECT_TRUE(isOnWiFiDataReceivedSuccess);
297 UnsetSocketCallback();
298 }
299
300 /*
301 * @tc.name: NOTIFY_DATA_RECEIVED_TEST_001
302 * @tc.desc: Notify channel data received.
303 * @tc.type: FUNC
304 * @tc.require:
305 */
306 HWTEST_F(AuthTcpConnectionTest, NOTIFY_DATA_RECEIVED_TEST_001, TestSize.Level1)
307 {
308 ListenerModule module = ListenerModule::AUTH_SESSION_KEY;
309 int32_t fd = 1;
310 SocketPktHead pktHead;
311 int32_t ret = SetSocketPktHead(&pktHead);
312 EXPECT_EQ(ret, SOFTBUS_OK);
313 const uint8_t data[AUTH_PKT_HEAD_LEN] = { 0 };
314 isOnDataReceivedSuccess = false;
315 NotifyDataReceived(module, fd, &pktHead, data);
316 EXPECT_FALSE(isOnDataReceivedSuccess);
317
318 pktHead.module = MODULE_AUTH_MSG;
319 AuthChannelListener listenerTestOne = {
320 .onDataReceived = OnDataReceived,
321 .onDisconnected = OnDisconnect,
322 };
323 AuthChannelListener listenerTestTwo = {
324 .onDataReceived = OnDataReceived,
325 .onDisconnected = OnDisconnect,
326 };
327 ret = RegAuthChannelListener(MODULE_AUTH_CHANNEL, &listenerTestOne);
328 EXPECT_EQ(ret, SOFTBUS_OK);
329 NotifyDataReceived(module, fd, &pktHead, data);
330 EXPECT_FALSE(isOnDataReceivedSuccess);
331
332 ret = RegAuthChannelListener(MODULE_AUTH_MSG, &listenerTestTwo);
333 NotifyDataReceived(module, fd, &pktHead, data);
334 EXPECT_TRUE(isOnDataReceivedSuccess);
335
336 isOnDataReceivedSuccess = false;
337 UnregAuthChannelListener(MODULE_AUTH_MSG);
338 NotifyDataReceived(module, fd, &pktHead, data);
339 EXPECT_FALSE(isOnDataReceivedSuccess);
340
341 pktHead.module = MODULE_META_AUTH;
342 NotifyDataReceived(module, fd, &pktHead, data);
343 EXPECT_FALSE(isOnDataReceivedSuccess);
344 UnregAuthChannelListener(MODULE_AUTH_CHANNEL);
345 }
346
347 /*
348 * @tc.name: NOTIFY_DATA_RECEIVED_TEST_002
349 * @tc.desc: Session notify data received.
350 * @tc.type: FUNC
351 * @tc.require:
352 */
353 HWTEST_F(AuthTcpConnectionTest, NOTIFY_DATA_RECEIVED_TEST_002, TestSize.Level1)
354 {
355 ListenerModule module = ListenerModule::AUTH_SESSION_KEY;
356 int32_t fd = 1;
357 SocketPktHead pktHead;
358 int32_t ret = SetSocketPktHead(&pktHead);
359 EXPECT_EQ(ret, SOFTBUS_OK);
360 pktHead.module = MODULE_SESSION_AUTH;
361 pktHead.len = AUTH_PKT_HEAD_LEN;
362 uint8_t data[AUTH_PKT_HEAD_LEN] = { 0 };
363 isOnWiFiDataReceivedSuccess = false;
364 SocketCallback socketCb = {
365 .onConnected = OnWiFiConnected,
366 .onDisconnected = OnWiFiDisconnected,
367 .onDataReceived = OnWiFiDataReceived,
368 };
369 ret = SetSocketCallback(&socketCb);
370 EXPECT_EQ(ret, SOFTBUS_OK);
371 NotifyDataReceived(module, fd, &pktHead, data);
372 EXPECT_TRUE(isOnWiFiDataReceivedSuccess);
373 UnsetSocketCallback();
374 }
375
376 /*
377 * @tc.name: NOTIFY_DATA_RECEIVED_TEST_003
378 * @tc.desc: Session notify data received.
379 * @tc.type: FUNC
380 * @tc.require:
381 */
382 HWTEST_F(AuthTcpConnectionTest, NOTIFY_DATA_RECEIVED_TEST_003, TestSize.Level1)
383 {
384 ListenerModule module = ListenerModule::LISTENER_MODULE_DYNAMIC_START;
385 int32_t fd = 1;
386 SocketPktHead pktHead;
387 int32_t ret = SetSocketPktHead(&pktHead);
388 EXPECT_EQ(ret, SOFTBUS_OK);
389 pktHead.module = MODULE_SESSION_KEY_AUTH;
390 pktHead.len = AUTH_PKT_HEAD_LEN;
391 uint8_t data[AUTH_PKT_HEAD_LEN] = { 0 };
392 isOnWiFiDataReceivedSuccess = false;
393 SocketCallback socketCb = {
394 .onConnected = OnWiFiConnected,
395 .onDisconnected = OnWiFiDisconnected,
396 .onDataReceived = OnWiFiDataReceived,
397 };
398 ret = SetSocketCallback(&socketCb);
399 EXPECT_EQ(ret, SOFTBUS_OK);
400 NotifyDataReceived(module, fd, &pktHead, data);
401 EXPECT_TRUE(isOnWiFiDataReceivedSuccess);
402
403 isOnWiFiDataReceivedSuccess = false;
404 module = ListenerModule::AUTH_SESSION_KEY;
405 NotifyDataReceived(module, fd, &pktHead, data);
406 EXPECT_TRUE(isOnWiFiDataReceivedSuccess);
407
408 isOnWiFiDataReceivedSuccess = false;
409 pktHead.module = MODULE_CONNECTION;
410 NotifyDataReceived(module, fd, &pktHead, data);
411 EXPECT_TRUE(isOnWiFiDataReceivedSuccess);
412 UnsetSocketCallback();
413
414 isOnWiFiDataReceivedSuccess = false;
415 NotifyDataReceived(module, fd, &pktHead, data);
416 EXPECT_FALSE(isOnWiFiDataReceivedSuccess);
417 }
418
419 /*
420 * @tc.name: RECV_PACKET_HEAD_TEST_001
421 * @tc.desc: recv packet head test
422 * @tc.type: FUNC
423 * @tc.require:
424 */
425 HWTEST_F(AuthTcpConnectionTest, RECV_PACKET_HEAD_TEST_001, TestSize.Level1)
426 {
427 int32_t fd = 0;
428 SocketPktHead pktHead;
429 (void)memset_s(&pktHead, sizeof(SocketPktHead), 0, sizeof(SocketPktHead));
430 int32_t ret = RecvPacketHead(AUTH, fd, &pktHead);
431 EXPECT_NE(ret, SOFTBUS_OK);
432 }
433
434 /*
435 * @tc.name: RECV_PACKET_DATA_TEST_001
436 * @tc.desc: recv packet head test
437 * @tc.type: FUNC
438 * @tc.require:
439 */
440 HWTEST_F(AuthTcpConnectionTest, RECV_PACKET_DATA_TEST_001, TestSize.Level1)
441 {
442 int32_t fd = 0;
443 SocketPktHead pktHead;
444 uint8_t data[TEST_DATA_LEN] = { 0 };
445 (void)memset_s(&pktHead, sizeof(SocketPktHead), 0, sizeof(SocketPktHead));
446 pktHead.module = MODULE_AUTH_CHANNEL;
447 NotifyDataReceived(AUTH, fd, &pktHead, data);
448 pktHead.module = MODULE_AUTH_MSG;
449 NotifyDataReceived(AUTH, fd, &pktHead, data);
450 pktHead.module = MODULE_CONNECTION;
451 NotifyDataReceived(AUTH, fd, &pktHead, data);
452
453 uint32_t len = TEST_DATA_LEN;
454 uint8_t *packetData = RecvPacketData(fd, len);
455 EXPECT_EQ(packetData, nullptr);
456 }
457
458 /*
459 * @tc.name: REQUIRE_AUTH_TCP_CONN_FD_LIST_LOCK_TEST_001
460 * @tc.desc: Require list lock.
461 * @tc.type: FUNC
462 * @tc.require:
463 */
464 HWTEST_F(AuthTcpConnectionTest, REQUIRE_AUTH_TCP_CONN_FD_LIST_LOCK_TEST_001, TestSize.Level1)
465 {
466 bool ret = RequireAuthTcpConnFdListLock();
467 EXPECT_FALSE(ret);
468 ReleaseAuthTcpConnFdListLock();
469
470 int32_t result = AuthTcpConnFdLockInit();
471 EXPECT_EQ(result, SOFTBUS_OK);
472
473 ret = RequireAuthTcpConnFdListLock();
474 EXPECT_TRUE(ret);
475 ReleaseAuthTcpConnFdListLock();
476 AuthTcpConnFdLockDeinit();
477 }
478
479 /*
480 * @tc.name: ADD_AUTH_TCP_CONN_FD_ITEM_TEST_001
481 * @tc.desc: AddAuthTcpConnFdItem test
482 * @tc.type: FUNC
483 * @tc.require:
484 */
485 HWTEST_F(AuthTcpConnectionTest, ADD_AUTH_TCP_CONN_FD_ITEM_TEST_001, TestSize.Level1)
486 {
487 int32_t fd = 1;
488
489 int32_t ret = AddAuthTcpConnFdItem(fd, AUTH_P2P);
490 EXPECT_EQ(ret, SOFTBUS_LOCK_ERR);
491 ret = AuthTcpConnFdLockInit();
492 EXPECT_EQ(ret, SOFTBUS_OK);
493 ret = AddAuthTcpConnFdItem(fd, AUTH_P2P);
494 EXPECT_EQ(ret, SOFTBUS_OK);
495 DeleteAuthTcpConnFdItemByConnId(fd);
496 AuthTcpConnFdLockDeinit();
497 }
498
499 /*
500 * @tc.name: IS_EXIST_AUTH_TCP_CONN_FD_ITEM_BY_COON_ID_TEST_001
501 * @tc.desc: is exist FdItem test.
502 * @tc.type: FUNC
503 * @tc.require:
504 */
505 HWTEST_F(AuthTcpConnectionTest, IS_EXIST_AUTH_TCP_CONN_FD_ITEM_BY_COON_ID_TEST_001, TestSize.Level1)
506 {
507 int32_t fd = 1;
508 bool ret = IsExistAuthTcpConnFdItemByConnId(fd);
509 EXPECT_FALSE(ret);
510 ret = IsExistAuthTcpConnFdItemWithoutLock(fd);
511 EXPECT_FALSE(ret);
512 int32_t result = AuthTcpConnFdLockInit();
513 EXPECT_EQ(result, SOFTBUS_OK);
514 ret = IsExistAuthTcpConnFdItemByConnId(fd);
515 EXPECT_FALSE(ret);
516 result = AddAuthTcpConnFdItem(fd, AUTH_P2P);
517 EXPECT_EQ(result, SOFTBUS_OK);
518 ret = IsExistAuthTcpConnFdItemByConnId(fd);
519 EXPECT_TRUE(ret);
520 ret = IsExistAuthTcpConnFdItemWithoutLock(fd);
521 EXPECT_TRUE(ret);
522 DeleteAuthTcpConnFdItemByConnId(fd);
523 AuthTcpConnFdLockDeinit();
524 }
525
526 /*
527 * @tc.name: PROCESS_SOCKET_OUT_EVENT_TEST_001
528 * @tc.desc: process socket out event test
529 * @tc.type: FUNC
530 * @tc.require:
531 */
532 HWTEST_F(AuthTcpConnectionTest, PROCESS_SOCKET_OUT_EVENT_TEST_001, TestSize.Level1)
533 {
534 int32_t fd = 0;
535 bool isClient = true;
536 NotifyConnected(AUTH, fd, isClient);
537 NotifyDisconnected(AUTH, fd);
538 StopSocketListening(AUTH);
539
540 int32_t ret = ProcessSocketOutEvent(AUTH, fd);
541 EXPECT_NE(ret, SOFTBUS_OK);
542 }
543
544 /*
545 * @tc.name: PROCESS_SOCKET_IN_EVENT_TEST_001
546 * @tc.desc: process socket in event test
547 * @tc.type: FUNC
548 * @tc.require:
549 */
550 HWTEST_F(AuthTcpConnectionTest, PROCESS_SOCKET_IN_EVENT_TEST_001, TestSize.Level1)
551 {
552 int32_t fd = 1;
553 int32_t ret = ProcessSocketInEvent(AUTH_USB, fd);
554 EXPECT_EQ(ret, SOFTBUS_LOCK_ERR);
555
556 int32_t result = AuthTcpConnFdLockInit();
557 EXPECT_EQ(result, SOFTBUS_OK);
558 ret = ProcessSocketInEvent(AUTH_USB, fd);
559 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
560
561 ret = AddAuthTcpConnFdItem(fd, AUTH_P2P);
562 EXPECT_EQ(result, SOFTBUS_OK);
563 ret = ProcessSocketInEvent(AUTH_USB, fd);
564 EXPECT_EQ(ret, SOFTBUS_INVALID_DATA_HEAD);
565
566 int32_t channelId = 0;
567 SocketPktHead head;
568 const uint8_t data[TEST_DATA_LEN] = { 0 };
569 (void)memset_s(&head, sizeof(SocketPktHead), 0, sizeof(SocketPktHead));
570 NotifyChannelDataReceived(channelId, &head, data);
571 NotifyChannelDisconnected(channelId);
572
573 ret = ProcessSocketInEvent(AUTH, fd);
574 EXPECT_NE(ret, SOFTBUS_OK);
575 AuthTcpConnFdLockDeinit();
576 }
577
578 /*
579 * @tc.name: IS_ENHANCE_P2P_MODULE_ID_TEST_001
580 * @tc.desc: is enhance p2p module id test
581 * @tc.type: FUNC
582 * @tc.require:
583 */
584 HWTEST_F(AuthTcpConnectionTest, IS_ENHANCE_P2P_MODULE_ID_TEST_001, TestSize.Level1)
585 {
586 ListenerModule moduleId = ListenerModule::AUTH_SESSION_KEY;
587 bool ret = IsEnhanceP2pModuleId(moduleId);
588 EXPECT_FALSE(ret);
589
590 moduleId = ListenerModule::AUTH_P2P;
591 ret = IsEnhanceP2pModuleId(moduleId);
592 EXPECT_FALSE(ret);
593
594 moduleId = ListenerModule::AUTH_ENHANCED_P2P_START;
595 ret = IsEnhanceP2pModuleId(moduleId);
596 EXPECT_TRUE(ret);
597 }
598
599 /*
600 * @tc.name: ON_CONNECT_EVENT_TEST_001
601 * @tc.desc: on connect event test
602 * @tc.type: FUNC
603 * @tc.require:
604 */
605 HWTEST_F(AuthTcpConnectionTest, ON_CONNECT_EVENT_TEST_001, TestSize.Level1)
606 {
607 ListenerModule module = AUTH;
608 int32_t cfd = -1;
609 ConnectOption clientAddr;
610 (void)memset_s(&clientAddr, sizeof(ConnectOption), 0, sizeof(ConnectOption));
611 int32_t ret = OnConnectEvent(module, cfd, &clientAddr);
612 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
613 cfd = 1;
614 ret = OnConnectEvent(module, cfd, &clientAddr);
615 EXPECT_EQ(ret, SOFTBUS_NETWORK_SET_KEEPALIVE_OPTION_FAIL);
616
617 module = AUTH_USB;
618 ret = OnConnectEvent(module, cfd, &clientAddr);
619 EXPECT_EQ(ret, SOFTBUS_NETWORK_SET_KEEPALIVE_OPTION_FAIL);
620
621 module = AUTH_P2P;
622 ret = OnConnectEvent(module, cfd, &clientAddr);
623 EXPECT_EQ(ret, SOFTBUS_NETWORK_SET_KEEPALIVE_OPTION_FAIL);
624
625 module = AUTH_RAW_P2P_CLIENT;
626 ret = OnConnectEvent(module, cfd, &clientAddr);
627 EXPECT_EQ(ret, SOFTBUS_NETWORK_SET_KEEPALIVE_OPTION_FAIL);
628 }
629
630 /*
631 * @tc.name: ON_DATA_EVENT_TEST_001
632 * @tc.desc: on data event test
633 * @tc.type: FUNC
634 * @tc.require:
635 */
636 HWTEST_F(AuthTcpConnectionTest, ON_DATA_EVENT_TEST_001, TestSize.Level1)
637 {
638 ListenerModule module = AUTH_P2P;
639 int32_t events = SOFTBUS_SOCKET_OUT;
640 int32_t fd = 0;
641 int32_t ret = OnDataEvent(module, events, fd);
642 EXPECT_NE(ret, SOFTBUS_OK);
643 events = SOFTBUS_SOCKET_IN;
644 ret = OnDataEvent(module, events, fd);
645 EXPECT_NE(ret, SOFTBUS_OK);
646 events = SOFTBUS_SOCKET_EXCEPTION;
647 ret = OnDataEvent(module, events, fd);
648 EXPECT_NE(ret, SOFTBUS_OK);
649 }
650
651 /*
652 * @tc.name: SET_SOCKET_CALLBACK_TEST_001
653 * @tc.desc: set socket callback test
654 * @tc.type: FUNC
655 * @tc.require:
656 */
657 HWTEST_F(AuthTcpConnectionTest, SET_SOCKET_CALLBACK_TEST_001, TestSize.Level1)
658 {
659 int32_t ret = SetSocketCallback(nullptr);
660 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
661 }
662
663 /*
664 * @tc.name: START_SOCKET_LISTENING_TEST_001
665 * @tc.desc: start socket listening test
666 * @tc.type: FUNC
667 * @tc.require:
668 */
669 HWTEST_F(AuthTcpConnectionTest, START_SOCKET_LISTENING_TEST_001, TestSize.Level1)
670 {
671 LocalListenerInfo info = {
672 .type = CONNECT_TCP,
673 .socketOption = {
674 .addr = "192.168.12.1",
675 .port = 22,
676 .moduleId = AUTH,
677 .protocol = LNN_PROTOCOL_IP,
678 },
679 };
680 int32_t ret = StartSocketListening(AUTH, &info);
681 EXPECT_NE(ret, SOFTBUS_OK);
682
683 StopSocketListening(AUTH);
684 }
685
686 /*
687 * @tc.name: AUTH_TCP_CREATE_LISTENER_TEST_001
688 * @tc.desc: AuthTcpCreateListener test
689 * @tc.type: FUNC
690 * @tc.require:
691 */
692 HWTEST_F(AuthTcpConnectionTest, AUTH_TCP_CREATE_LISTENER_TEST_001, TestSize.Level1)
693 {
694 ListenerModule module = PROXY;
695 int32_t fd = 1;
696 TriggerType trigger = READ_TRIGGER;
697
698 int32_t ret = AuthTcpCreateListener(module, fd, trigger);
699 EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
700 }
701
702 /*
703 * @tc.name: SOCKET_GET_CONN_INFO_TEST_001
704 * @tc.desc: socket get conn info test
705 * @tc.type: FUNC
706 * @tc.require:
707 */
708 HWTEST_F(AuthTcpConnectionTest, SOCKET_GET_CONN_INFO_TEST_001, TestSize.Level1)
709 {
710 int32_t fd = 0;
711 AuthConnInfo connInfo = {
712 .type = AUTH_LINK_TYPE_WIFI,
713 };
714 bool isServer;
715 (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
716 int32_t ret = SocketGetConnInfo(fd, nullptr, &isServer, WLAN_IF);
717 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
718 ret = SocketGetConnInfo(fd, &connInfo, nullptr, WLAN_IF);
719 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
720 ret = SocketGetConnInfo(fd, &connInfo, &isServer, WLAN_IF);
721 EXPECT_NE(ret, SOFTBUS_OK);
722 }
723
724 /*
725 * @tc.name: SOCKET_GET_CONN_INFO_TEST_002
726 * @tc.desc: Get conn info test
727 * @tc.type: FUNC
728 * @tc.require:
729 */
730 HWTEST_F(AuthTcpConnectionTest, SOCKET_GET_CONN_INFO_TEST_002, TestSize.Level1)
731 {
732 int32_t fd = -1;
733 AuthConnInfo connInfo = {
734 .type = AUTH_LINK_TYPE_WIFI,
735 };
736 bool isServer = true;
737 int32_t ifnameIdx = 1;
738
739 SetSessionKeyListenerModule(fd);
740 StopSessionKeyListening(fd);
741 fd = USB_IF;
742 SetSessionKeyListenerModule(fd);
743 StopSessionKeyListening(fd);
744 (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
745 int32_t ret = SocketGetConnInfo(fd, nullptr, &isServer, ifnameIdx);
746 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
747
748 ret = SocketGetConnInfo(fd, &connInfo, nullptr, ifnameIdx);
749 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
750
751 ret = SocketGetConnInfo(fd, &connInfo, &isServer, ifnameIdx);
752 EXPECT_EQ(ret, SOFTBUS_AUTH_GET_PEER_SOCKET_ADDR_FAIL);
753
754 fd = WLAN_IF;
755 ret = SocketGetConnInfo(fd, &connInfo, &isServer, ifnameIdx);
756 EXPECT_EQ(ret, SOFTBUS_AUTH_GET_PEER_SOCKET_ADDR_FAIL);
757 }
758
759 /*
760 * @tc.name: SOCKET_CONNECT_INNER_TEST_001
761 * @tc.desc: SocketConnectInner test
762 * @tc.type: FUNC
763 * @tc.require:
764 */
765 HWTEST_F(AuthTcpConnectionTest, SOCKET_CONNECT_INNER_TEST_001, TestSize.Level1)
766 {
767 const char *localIp = "192.168.11.22";
768 const char *peerIp = "192.168.11.33";
769 int32_t ret = SocketConnectInner(nullptr, peerIp, 37025, AUTH, true);
770 EXPECT_EQ(ret, AUTH_INVALID_FD);
771 ret = SocketConnectInner(localIp, nullptr, 37025, AUTH, true);
772 EXPECT_EQ(ret, AUTH_INVALID_FD);
773 ret = SocketConnectInner(localIp, peerIp, 37025, AUTH, true);
774 EXPECT_EQ(ret, SOFTBUS_CONN_SOCKET_GET_INTERFACE_ERR);
775 }
776
777 /*
778 * @tc.name: SOCKET_CONNECT_DEVICE_WITH_APP_IP_TEST_001
779 * @tc.desc: SocketConnectDeviceWithAllIp test
780 * @tc.type: FUNC
781 * @tc.require:
782 */
783 HWTEST_F(AuthTcpConnectionTest, SOCKET_CONNECT_DEVICE_WITH_APP_IP_TEST_001, TestSize.Level1)
784 {
785 const char *localIp = "192.168.11.22";
786 const char *peerIp = "192.168.11.33";
787 int32_t ret = SocketConnectDeviceWithAllIp(localIp, peerIp, 37025, true);
788 EXPECT_EQ(ret, SOFTBUS_CONN_SOCKET_GET_INTERFACE_ERR);
789 }
790
791 /*
792 * @tc.name: SOCKET_SET_DEVICE_TEST_001
793 * @tc.desc: Socket set device test
794 * @tc.type: FUNC
795 * @tc.require:
796 */
797 HWTEST_F(AuthTcpConnectionTest, SOCKET_SET_DEVICE_TEST_001, TestSize.Level1)
798 {
799 int32_t fd = -1;
800 bool isBlockMode = true;
801 int32_t ret = SocketSetDevice(fd, isBlockMode);
802 EXPECT_EQ(ret, SOFTBUS_INVALID_FD);
803
804 fd = 1;
805 ret = SocketSetDevice(fd, isBlockMode);
806 EXPECT_EQ(ret, SOFTBUS_INVALID_FD);
807 }
808
809 /*
810 * @tc.name: SET_TCP_KEEP_ALIVE_AND_IP_TOS_TEST_001
811 * @tc.desc: SetTcpKeepaliveAndIpTos test
812 * @tc.type: FUNC
813 * @tc.require:
814 */
815 HWTEST_F(AuthTcpConnectionTest, SET_TCP_KEEP_ALIVE_AND_IP_TOS_TEST_001, TestSize.Level1)
816 {
817 bool isBlockMode = true;
818 int32_t ifnameIdx = 1;
819 TriggerType triggerMode = TriggerType::READ_TRIGGER;
820 ListenerModule module = PROXY;
821 int32_t fd = -1;
822 int32_t ret = SetTcpKeepaliveAndIpTos(isBlockMode, ifnameIdx, triggerMode, module, fd);
823 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
824
825 fd = 1;
826 ret = SetTcpKeepaliveAndIpTos(isBlockMode, ifnameIdx, triggerMode, module, fd);
827 EXPECT_EQ(ret, SOFTBUS_ADAPTER_ERR);
828 }
829
830 /*
831 * @tc.name: SOCKET_CONNECT_DEVICE_TEST_001
832 * @tc.desc: SocketConnectDevice test
833 * @tc.type: FUNC
834 * @tc.require:
835 */
836 HWTEST_F(AuthTcpConnectionTest, SOCKET_CONNECT_DEVICE_TEST_001, TestSize.Level1)
837 {
838 const char *addr = "192.168.11.44";
839 int32_t port = 37025;
840 bool isBlockMode = true;
841 int32_t ifnameIdx = 1;
842 int32_t ret = SocketConnectDevice(nullptr, port, isBlockMode, ifnameIdx);
843 EXPECT_EQ(ret, AUTH_INVALID_FD);
844 ret = SocketConnectDevice(addr, port, isBlockMode, ifnameIdx);
845 EXPECT_EQ(ret, AUTH_INVALID_FD);
846 }
847
848 /*
849 * @tc.name: NIP_SOCKET_CONNECT_DEVICE_TEST_001
850 * @tc.desc: NipSocketConnectDevice test
851 * @tc.type: FUNC
852 * @tc.require:
853 */
854 HWTEST_F(AuthTcpConnectionTest, NIP_SOCKET_CONNECT_DEVICE_TEST_001, TestSize.Level1)
855 {
856 const char *addr = "192.168.11.44";
857 int32_t ret = NipSocketConnectDevice(AUTH, addr, 37025, true);
858 EXPECT_EQ(ret, AUTH_INVALID_FD);
859 ret = NipSocketConnectDevice(AUTH, nullptr, 37025, true);
860 EXPECT_EQ(ret, AUTH_INVALID_FD);
861 }
862
863 /*
864 * @tc.name: SOCKET_POST_BYTES_TEST_001
865 * @tc.desc: Socket post bytes test
866 * @tc.type: FUNC
867 * @tc.require:
868 */
869 HWTEST_F(AuthTcpConnectionTest, SOCKET_POST_BYTES_TEST_001, TestSize.Level1)
870 {
871 int32_t fd = 1;
872 AuthDataHead dataHead = {
873 .dataType = 1,
874 .module = AUTH,
875 .seq = 2,
876 .flag = 3,
877 .len = AUTH_PKT_HEAD_LEN,
878 };
879 const uint8_t data[AUTH_PKT_HEAD_LEN] = { 0 };
880
881 int32_t ret = SocketPostBytes(fd, nullptr, nullptr);
882 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
883
884 ret = SocketPostBytes(fd, &dataHead, nullptr);
885 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
886
887 ret = SocketPostBytes(fd, &dataHead, data);
888 EXPECT_EQ(ret, SOFTBUS_LOCK_ERR);
889
890 int32_t result = AuthTcpConnFdLockInit();
891 EXPECT_EQ(result, SOFTBUS_OK);
892 ret = SocketPostBytes(fd, &dataHead, data);
893 EXPECT_EQ(ret, SOFTBUS_TCP_SOCKET_ERR);
894
895 dataHead.module = AUTH_USB;
896 ret = SocketPostBytes(fd, &dataHead, data);
897 EXPECT_EQ(ret, SOFTBUS_TCP_SOCKET_ERR);
898 }
899
900 /*
901 * @tc.name: NOTIFY_CHANNEL_DATA_RECEIVED_TEST_001
902 * @tc.desc: Notification of receipt of data.
903 * @tc.type: FUNC
904 * @tc.require:
905 */
906 HWTEST_F(AuthTcpConnectionTest, NOTIFY_CHANNEL_DATA_RECEIVED_TEST_001, TestSize.Level1)
907 {
908 SocketPktHead pktHead;
909 int32_t ret = SetSocketPktHead(&pktHead);
910 EXPECT_EQ(ret, SOFTBUS_OK);
911 uint8_t data[AUTH_PKT_HEAD_LEN] = { 0 };
912 int32_t channelId = 1;
913 isOnDataReceivedSuccess = false;
914 NotifyChannelDataReceived(channelId, &pktHead, data);
915 EXPECT_FALSE(isOnDataReceivedSuccess);
916
917 pktHead.module = MODULE_AUTH_MSG;
918 AuthChannelListener listenerTestOne = {
919 .onDataReceived = OnDataReceived,
920 .onDisconnected = OnDisconnect,
921 };
922 AuthChannelListener listenerTestTwo = {
923 .onDataReceived = OnDataReceived,
924 .onDisconnected = OnDisconnect,
925 };
926 ret = RegAuthChannelListener(MODULE_AUTH_CHANNEL, &listenerTestOne);
927 EXPECT_EQ(ret, SOFTBUS_OK);
928 ret = RegAuthChannelListener(MODULE_AUTH_MSG, &listenerTestTwo);
929 EXPECT_EQ(ret, SOFTBUS_OK);
930 NotifyChannelDataReceived(channelId, &pktHead, data);
931 EXPECT_TRUE(isOnDataReceivedSuccess);
932 UnregAuthChannelListener(MODULE_AUTH_MSG);
933 UnregAuthChannelListener(MODULE_AUTH_CHANNEL);
934 }
935
936 /*
937 * @tc.name: NOTIFY_CHANNEL_DISCONNECTED_TEST_001
938 * @tc.desc: Notification channel disconnected.
939 * @tc.type: FUNC
940 * @tc.require:
941 */
942 HWTEST_F(AuthTcpConnectionTest, NOTIFY_CHANNEL_DISCONNECTED_TEST_001, TestSize.Level1)
943 {
944 int32_t channelId = 1;
945 isOnDisconnectSuccess = false;
946 NotifyChannelDisconnected(channelId);
947 EXPECT_FALSE(isOnDisconnectSuccess);
948
949 AuthChannelListener listenerTestOne = {
950 .onDataReceived = OnDataReceived,
951 .onDisconnected = OnDisconnect,
952 };
953 int32_t ret = RegAuthChannelListener(MODULE_AUTH_CHANNEL, &listenerTestOne);
954 EXPECT_EQ(ret, SOFTBUS_OK);
955 NotifyChannelDisconnected(channelId);
956 EXPECT_TRUE(isOnDisconnectSuccess);
957 UnregAuthChannelListener(MODULE_AUTH_CHANNEL);
958 }
959
960 /*
961 * @tc.name: REG_AUTH_CHANNEL_LISTENER_TEST_001
962 * @tc.desc: register listener.
963 * @tc.type: FUNC
964 * @tc.require:
965 */
966 HWTEST_F(AuthTcpConnectionTest, REG_AUTH_CHANNEL_LISTENER_TEST_001, TestSize.Level1)
967 {
968 int32_t ret = RegAuthChannelListener(MODULE_AUTH_CHANNEL, nullptr);
969 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
970
971 AuthChannelListener listenerTestOne = {
972 .onDataReceived = nullptr,
973 .onDisconnected = OnDisconnect,
974 };
975 ret = RegAuthChannelListener(MODULE_AUTH_CHANNEL, &listenerTestOne);
976 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
977
978 listenerTestOne.onDataReceived = OnDataReceived;
979 ret = RegAuthChannelListener(MODULE_AUTH_CHANNEL, &listenerTestOne);
980 EXPECT_EQ(ret, SOFTBUS_OK);
981
982 ret = RegAuthChannelListener(MODULE_AUTH_SDK, &listenerTestOne);
983 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
984 UnregAuthChannelListener(MODULE_AUTH_CHANNEL);
985 }
986
987 /*
988 * @tc.name: AUTH_OPEN_CHANNEL_WITH_ALL_IP_TEST_001
989 * @tc.desc: AuthOpenChannelWithAllIp test
990 * @tc.type: FUNC
991 * @tc.require:
992 */
993 HWTEST_F(AuthTcpConnectionTest, AUTH_OPEN_CHANNEL_WITH_ALL_IP_TEST_001, TestSize.Level1)
994 {
995 const char *localIp = "192.168.11.22";
996 const char *remoteIp = "192.168.11.33";
997 int32_t ret = AuthOpenChannelWithAllIp(localIp, remoteIp, 37025);
998 EXPECT_EQ(ret, INVALID_CHANNEL_ID);
999 ret = AuthOpenChannelWithAllIp(nullptr, remoteIp, 37025);
1000 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1001 ret = AuthOpenChannelWithAllIp(localIp, nullptr, 37025);
1002 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1003 ret = AuthOpenChannelWithAllIp(localIp, remoteIp, 0);
1004 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1005 }
1006
1007 /*
1008 * @tc.name: AUTH_OPEN_CHANNEL_WITH_ALL_IP_TEST_001
1009 * @tc.desc: open channel test
1010 * @tc.type: FUNC
1011 * @tc.require:
1012 */
1013 HWTEST_F(AuthTcpConnectionTest, AUTH_OPEN_CHANNEL_TEST_001, TestSize.Level1)
1014 {
1015 const char *addr = "192.168.11.22";
1016 int32_t port = 0;
1017 int32_t ifnameIdx = 1;
1018 int32_t ret = AuthOpenChannel(nullptr, port, ifnameIdx);
1019 EXPECT_EQ(ret, INVALID_CHANNEL_ID);
1020
1021 ret = AuthOpenChannel(addr, port, ifnameIdx);
1022 EXPECT_EQ(ret, INVALID_CHANNEL_ID);
1023
1024 port = 1;
1025 ret = AuthOpenChannel(addr, port, ifnameIdx);
1026 EXPECT_EQ(ret, INVALID_CHANNEL_ID);
1027 }
1028
1029 /*
1030 * @tc.name: AUTH_POST_CHANNEL_DATA_TEST_001
1031 * @tc.desc: post channel data test
1032 * @tc.type: FUNC
1033 * @tc.require:
1034 */
1035 HWTEST_F(AuthTcpConnectionTest, AUTH_POST_CHANNEL_DATA_TEST_001, TestSize.Level1)
1036 {
1037 int32_t channelId = -1;
1038 AuthChannelData channelData = {
1039 .module = AUTH,
1040 .flag = 2,
1041 .seq = 3,
1042 .len = 0,
1043 };
1044 int32_t ret = AuthPostChannelData(channelId, nullptr);
1045 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1046
1047 channelId = 1;
1048 ret = AuthPostChannelData(channelId, nullptr);
1049 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1050
1051 ret = AuthPostChannelData(channelId, &channelData);
1052 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1053
1054 uint8_t data = 123;
1055 channelData.data = &data;
1056 ret = AuthPostChannelData(channelId, &channelData);
1057 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1058
1059 channelData.len = AUTH_PKT_HEAD_LEN;
1060 ret = AuthPostChannelData(channelId, &channelData);
1061 EXPECT_EQ(ret, SOFTBUS_TCP_SOCKET_ERR);
1062 }
1063
1064 /*
1065 * @tc.name: GET_TCP_KEEP_ALIVE_OPTION_BY_CYCLE_TEST_001
1066 * @tc.desc: get option test
1067 * @tc.type: FUNC
1068 * @tc.require:
1069 */
1070 HWTEST_F(AuthTcpConnectionTest, GET_TCP_KEEP_ALIVE_OPTION_BY_CYCLE_TEST_001, TestSize.Level1)
1071 {
1072 ModeCycle cycle = (ModeCycle)1;
1073 TcpKeepaliveOption option = { 0 };
1074 int32_t ret = GetTcpKeepaliveOptionByCycle(cycle, nullptr);
1075 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1076
1077 ret = GetTcpKeepaliveOptionByCycle(cycle, &option);
1078 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1079
1080 cycle = HIGH_FREQ_CYCLE;
1081 ret = GetTcpKeepaliveOptionByCycle(cycle, &option);
1082 EXPECT_EQ(ret, SOFTBUS_OK);
1083
1084 cycle = MID_FREQ_CYCLE;
1085 ret = GetTcpKeepaliveOptionByCycle(cycle, &option);
1086 EXPECT_EQ(ret, SOFTBUS_OK);
1087
1088 cycle = LOW_FREQ_CYCLE;
1089 ret = GetTcpKeepaliveOptionByCycle(cycle, &option);
1090 EXPECT_EQ(ret, SOFTBUS_OK);
1091
1092 cycle = DEFAULT_FREQ_CYCLE;
1093 ret = GetTcpKeepaliveOptionByCycle(cycle, &option);
1094 EXPECT_EQ(ret, SOFTBUS_OK);
1095 }
1096
1097 /*
1098 * @tc.name: AUTH_SET_TCP_KEEP_ALIVE_OPTION_TEST_001
1099 * @tc.desc: set option test
1100 * @tc.type: FUNC
1101 * @tc.require:
1102 */
1103 HWTEST_F(AuthTcpConnectionTest, AUTH_SET_TCP_KEEP_ALIVE_OPTION_TEST_001, TestSize.Level1)
1104 {
1105 int32_t fd = 0;
1106 ModeCycle cycle = (ModeCycle)1;
1107 int32_t ret = AuthSetTcpKeepaliveOption(fd, cycle);
1108 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1109
1110 fd = 1;
1111 ret = AuthSetTcpKeepaliveOption(fd, cycle);
1112 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1113
1114 cycle = (ModeCycle)666;
1115 ret = AuthSetTcpKeepaliveOption(fd, cycle);
1116 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1117
1118 cycle = MID_FREQ_CYCLE;
1119 ret = AuthSetTcpKeepaliveOption(fd, cycle);
1120 EXPECT_EQ(ret, SOFTBUS_ADAPTER_ERR);
1121 }
1122
1123 /*
1124 * @tc.name: GET_CONNECT_OPTION_BY_IFNAME_TEST_001
1125 * @tc.desc: GetConnectOptionByIfname test
1126 * @tc.type: FUNC
1127 * @tc.require:
1128 */
1129 HWTEST_F(AuthTcpConnectionTest, GET_CONNECT_OPTION_BY_IFNAME_TEST_001, TestSize.Level1)
1130 {
1131 int32_t ifnameIdx = 0;
1132 int32_t port = 1;
1133
1134 ConnectOption option = GetConnectOptionByIfname(ifnameIdx, port);
1135 EXPECT_EQ(option.socketOption.moduleId, AUTH);
1136 ifnameIdx = 1;
1137 option = GetConnectOptionByIfname(ifnameIdx, port);
1138 EXPECT_EQ(option.socketOption.moduleId, AUTH_USB);
1139 }
1140 } // namespace OHOS
1141