1 /*
2 * Copyright (c) 2021-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 <gtest/gtest.h>
17 #include <sys/socket.h>
18
19 #include "client_trans_tcp_direct_manager.c"
20 #include "client_trans_tcp_direct_manager.h"
21 #include "client_trans_tcp_direct_message.c"
22 #include "client_trans_tcp_direct_listener.c"
23 #include "client_trans_tcp_direct_message.h"
24 #include "client_trans_session_manager.h"
25 #include "client_trans_socket_manager.h"
26 #include "client_trans_session_callback.h"
27 #include "session.h"
28 #include "softbus_def.h"
29 #include "softbus_error_code.h"
30 #include "softbus_app_info.h"
31 #include "softbus_feature_config.h"
32 #include "softbus_access_token_test.h"
33 #include "softbus_conn_interface.h"
34 #include "softbus_socket.h"
35 #include "trans_tcp_direct_mock.h"
36 #include "trans_tcp_process_data.h"
37 #include "trans_tcp_process_data.c"
38
39 #define MAX_LEN 2048
40 #define TEST_FD 10
41 #define COUNT 11
42 #define PKG_LEN 32
43 #define RECV_BUF "testABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00"
44 #define BUF_LEN 10
45 #define COUNT 11
46 #define SESSIONKEY_LEN 32
47 #define INVALID_VALUE (-1)
48
49 #define TRANS_TEST_SESSION_ID 10
50 #define TRANS_TEST_CHANNEL_ID 1000
51 #define TRANS_TEST_FILE_ENCRYPT 10
52 #define TRANS_TEST_ALGORITHM 1
53 #define TRANS_TEST_CRC 1
54 #define TRANS_TEST_FD 1000
55 #define TRANS_TEST_ADDR_INFO_NUM 2
56 #define TRANS_TEST_INVALID_SESSION_ID (-1)
57
58 using namespace testing;
59 using namespace testing::ext;
60
61 namespace OHOS {
62 const char *g_pkgName = "dms";
63 const char *g_sessionName = "ohos.distributedschedule.dms.test";
64 const char *g_networkid = "ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00";
65 const char *g_deviceId = "ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF0";
66 const char *g_groupId = "TEST_GROUP_ID";
67 static const char *g_sessionkey = "clientkey";
68 static int32_t g_fd = socket(AF_INET, SOCK_STREAM, 0);
69 static SessionAttribute g_sessionAttr = {
70 .dataType = TYPE_BYTES,
71 };
72
73 class TransTcpDirectTest : public testing::Test {
74 public:
TransTcpDirectTest()75 TransTcpDirectTest()
76 {}
~TransTcpDirectTest()77 ~TransTcpDirectTest()
78 {}
79 static void SetUpTestCase(void);
80 static void TearDownTestCase(void);
SetUp()81 void SetUp() override
82 {}
TearDown()83 void TearDown() override
84 {}
85 };
86
SetUpTestCase(void)87 void TransTcpDirectTest::SetUpTestCase(void)
88 {
89 int32_t ret = TransClientInit();
90 ASSERT_EQ(ret, SOFTBUS_OK);
91 SetAccessTokenPermission("dsoftbusTransTest");
92 }
93
TearDownTestCase(void)94 void TransTcpDirectTest::TearDownTestCase(void)
95 {
96 }
97
OnSessionOpened(int32_t sessionId,int32_t result)98 static int32_t OnSessionOpened(int32_t sessionId, int32_t result)
99 {
100 TRANS_LOGI(TRANS_TEST, "session opened, sessionId=%{public}d", sessionId);
101 return SOFTBUS_OK;
102 }
103
OnSessionClosed(int32_t sessionId)104 static void OnSessionClosed(int32_t sessionId)
105 {
106 TRANS_LOGI(TRANS_TEST, "session closed, sessionId=%{public}d", sessionId);
107 }
108
OnBytesReceived(int32_t sessionId,const void * data,unsigned int len)109 static void OnBytesReceived(int32_t sessionId, const void *data, unsigned int len)
110 {
111 TRANS_LOGI(TRANS_TEST, "session bytes received, sessionId=%{public}d", sessionId);
112 }
113
OnMessageReceived(int32_t sessionId,const void * data,unsigned int len)114 static void OnMessageReceived(int32_t sessionId, const void *data, unsigned int len)
115 {
116 TRANS_LOGI(TRANS_TEST, "session msg received, sessionId=%{public}d", sessionId);
117 }
118
119 static ISessionListener g_sessionlistener = {
120 .OnSessionOpened = OnSessionOpened,
121 .OnSessionClosed = OnSessionClosed,
122 .OnBytesReceived = OnBytesReceived,
123 .OnMessageReceived = OnMessageReceived,
124 };
125
126 /**
127 * @tc.name: CreateSessionServerTest001
128 * @tc.desc: extern module active publish, use the wrong parameter.
129 * @tc.type: FUNC
130 * @tc.require:I5HQGA
131 */
132 HWTEST_F(TransTcpDirectTest, CreateSessionServerTest001, TestSize.Level1)
133 {
134 int32_t ret;
135 ret = CreateSessionServer(nullptr, g_sessionName, &g_sessionlistener);
136 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
137
138 ret = CreateSessionServer(g_pkgName, nullptr, &g_sessionlistener);
139 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
140
141 ret = CreateSessionServer(g_pkgName, g_sessionName, nullptr);
142 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
143
144 ret = CreateSessionServer(g_pkgName, g_sessionName, &g_sessionlistener);
145 EXPECT_EQ(SOFTBUS_OK, ret);
146
147 ret = RemoveSessionServer(g_pkgName, g_sessionName);
148 EXPECT_EQ(SOFTBUS_OK, ret);
149 }
150
151 /**
152 * @tc.name: CreateSessionServerTest002
153 * @tc.desc: extern module active publish, use the normal parameter.
154 * @tc.type: FUNC
155 * @tc.require:I5HQGA
156 */
157 HWTEST_F(TransTcpDirectTest, CreateSessionServerTest002, TestSize.Level1)
158 {
159 int32_t ret;
160 ret = CreateSessionServer(g_pkgName, g_sessionName, &g_sessionlistener);
161 EXPECT_EQ(SOFTBUS_OK, ret);
162
163 ret = RemoveSessionServer(g_pkgName, g_sessionName);
164 EXPECT_EQ(SOFTBUS_OK, ret);
165 }
166
167 /**
168 * @tc.name: CreateSessionServerTest003
169 * @tc.desc: extern module active publish, use the same normal parameter.
170 * @tc.type: FUNC
171 * @tc.require:I5HQGA
172 */
173 HWTEST_F(TransTcpDirectTest, CreateSessionServerTest003, TestSize.Level1)
174 {
175 int32_t ret;
176 ret = CreateSessionServer(g_pkgName, g_sessionName, &g_sessionlistener);
177 EXPECT_EQ(SOFTBUS_OK, ret);
178
179 ret = CreateSessionServer(g_pkgName, g_sessionName, &g_sessionlistener);
180 EXPECT_EQ(SOFTBUS_OK, ret);
181
182 ret = RemoveSessionServer(g_pkgName, g_sessionName);
183 EXPECT_EQ(SOFTBUS_OK, ret);
184 }
185
186 /**
187 * @tc.name: CreateSessionServerTest004
188 * @tc.desc: extern module active publish, create 11 sessionServer, succ 10, failed at 11th.
189 * @tc.type: FUNC
190 * @tc.require:I5HQGA
191 */
192 HWTEST_F(TransTcpDirectTest, CreateSessionServerTest004, TestSize.Level1)
193 {
194 int32_t ret, i;
195 char const *sessionName[MAX_SESSION_SERVER_NUMBER + 1] = {
196 "ohos.distributedschedule.dms.test0",
197 "ohos.distributedschedule.dms.test1",
198 "ohos.distributedschedule.dms.test2",
199 "ohos.distributedschedule.dms.test3",
200 "ohos.distributedschedule.dms.test4",
201 "ohos.distributedschedule.dms.test5",
202 "ohos.distributedschedule.dms.test6",
203 "ohos.distributedschedule.dms.test7",
204 "ohos.distributedschedule.dms.test8",
205 "ohos.distributedschedule.dms.test9",
206 "ohos.distributedschedule.dms.test10"
207 };
208
209 for (i = 0; i < COUNT; i++) {
210 ret = CreateSessionServer(g_pkgName, sessionName[i], &g_sessionlistener);
211 EXPECT_EQ(SOFTBUS_OK, ret);
212 }
213 for (i = COUNT; i < MAX_SESSION_SERVER_NUMBER; i++) {
214 ret = CreateSessionServer(g_pkgName, sessionName[i], &g_sessionlistener);
215 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
216 }
217 ret = CreateSessionServer(g_pkgName, sessionName[i], &g_sessionlistener);
218 EXPECT_NE(SOFTBUS_OK, ret);
219
220 for (i = 0; i < COUNT; i++) {
221 ret = RemoveSessionServer(g_pkgName, sessionName[i]);
222 EXPECT_EQ(SOFTBUS_OK, ret);
223 }
224 for (i = COUNT; i < MAX_SESSION_SERVER_NUMBER; i++) {
225 ret = RemoveSessionServer(g_pkgName, sessionName[i]);
226 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
227 }
228 }
229
230 /**
231 * @tc.name: RemoveSessionServerTest001
232 * @tc.desc: extern module active publish, use the wrong parameter.
233 * @tc.type: FUNC
234 * @tc.require:
235 */
236 HWTEST_F(TransTcpDirectTest, RemoveSessionServerTest001, TestSize.Level1)
237 {
238 int32_t ret;
239 ret = RemoveSessionServer(nullptr, g_sessionName);
240 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
241
242 ret = RemoveSessionServer(g_pkgName, nullptr);
243 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
244 }
245
246 /**
247 * @tc.name: RemoveSessionServerTest002
248 * @tc.desc: extern module active publish, use the same parameter.
249 * @tc.type: FUNC
250 * @tc.require:I5HQGA
251 */
252 HWTEST_F(TransTcpDirectTest, RemoveSessionServerTest002, TestSize.Level1)
253 {
254 int32_t ret;
255 ret = CreateSessionServer(g_pkgName, g_sessionName, &g_sessionlistener);
256 EXPECT_EQ(SOFTBUS_OK, ret);
257
258 ret = RemoveSessionServer(g_pkgName, g_sessionName);
259 EXPECT_EQ(SOFTBUS_OK, ret);
260
261 ret = RemoveSessionServer(g_pkgName, g_sessionName);
262 EXPECT_EQ(SOFTBUS_TRANS_CHECK_PID_ERROR, ret);
263 }
264
265 /**
266 * @tc.name: OpenSessionTest001
267 * @tc.desc: extern module active publish, use the wrong parameter.
268 * @tc.type: FUNC
269 * @tc.require:I5HQGA
270 */
271 HWTEST_F(TransTcpDirectTest, OpenSessionTest001, TestSize.Level1)
272 {
273 int32_t ret;
274 g_sessionAttr.dataType = TYPE_BYTES;
275
276 ret = OpenSession(nullptr, g_sessionName, g_networkid, g_groupId, &g_sessionAttr);
277 EXPECT_GE(SOFTBUS_OK, ret);
278
279 ret = OpenSession(g_sessionName, nullptr, g_networkid, g_groupId, &g_sessionAttr);
280 EXPECT_GE(SOFTBUS_OK, ret);
281
282 ret = OpenSession(g_sessionName, g_sessionName, nullptr, g_groupId, &g_sessionAttr);
283 EXPECT_GE(SOFTBUS_OK, ret);
284
285 ret = OpenSession(g_sessionName, g_sessionName, g_networkid, nullptr, &g_sessionAttr);
286 EXPECT_GE(SOFTBUS_OK, ret);
287
288 ret = OpenSession(g_sessionName, g_sessionName, g_networkid, g_groupId, nullptr);
289 EXPECT_GE(SOFTBUS_OK, ret);
290
291 g_sessionAttr.dataType = TYPE_BUTT;
292 ret = OpenSession(g_sessionName, g_sessionName, g_networkid, g_groupId, &g_sessionAttr);
293 g_sessionAttr.dataType = TYPE_BYTES;
294 EXPECT_GE(SOFTBUS_OK, ret);
295 }
296
297 /**
298 * @tc.name: SendBytesTest001
299 * @tc.desc: extern module active publish, use the wrong parameter.
300 * @tc.type: FUNC
301 * @tc.require:
302 */
303 HWTEST_F(TransTcpDirectTest, SendBytesTest001, TestSize.Level1)
304 {
305 int32_t ret;
306 int32_t sessionId = 1;
307 const char *data = "testdata";
308 uint32_t len = strlen(data);
309 uint32_t maxLen;
310
311 ret = SendBytes(-1, data, len);
312 EXPECT_NE(SOFTBUS_OK, ret);
313
314 ret = SendBytes(sessionId, nullptr, len);
315 EXPECT_NE(SOFTBUS_OK, ret);
316
317 ret = SendBytes(sessionId, data, 0);
318 EXPECT_NE(SOFTBUS_OK, ret);
319
320 ret = SoftbusGetConfig(SOFTBUS_INT_MAX_BYTES_LENGTH, (unsigned char *)&maxLen, sizeof(maxLen));
321 ASSERT_EQ(SOFTBUS_OK, ret);
322 ret = SendMessage(sessionId, data, maxLen + 1);
323 EXPECT_NE(SOFTBUS_OK, ret);
324 }
325
326 /**
327 * @tc.name: SendMessageTest001
328 * @tc.desc: extern module active publish, use the wrong parameter.
329 * @tc.type: FUNC
330 * @tc.require:
331 */
332 HWTEST_F(TransTcpDirectTest, SendMessageTest001, TestSize.Level1)
333 {
334 int32_t ret;
335 int32_t sessionId = 1;
336 const char *data = "testdata";
337 uint32_t len = strlen(data);
338 uint32_t maxLen;
339
340 ret = SendMessage(-1, data, len);
341 EXPECT_NE(SOFTBUS_OK, ret);
342
343 ret = SendMessage(sessionId, nullptr, len);
344 EXPECT_NE(SOFTBUS_OK, ret);
345
346 ret = SendMessage(sessionId, data, 0);
347 EXPECT_NE(SOFTBUS_OK, ret);
348
349 ret = SoftbusGetConfig(SOFTBUS_INT_MAX_MESSAGE_LENGTH, (unsigned char *)&maxLen, sizeof(maxLen));
350 ASSERT_EQ(SOFTBUS_OK, ret);
351 ret = SendMessage(sessionId, data, maxLen + 1);
352 EXPECT_NE(SOFTBUS_OK, ret);
353 }
354
355 /**
356 * @tc.name: TransClientGetTdcDataBufByChannelTest001
357 * @tc.desc: improve branch coverage, use the wrong or normal parameter.
358 * @tc.type: FUNC
359 * @tc.require:
360 */
361 HWTEST_F(TransTcpDirectTest, TransClientGetTdcDataBufByChannelTest001, TestSize.Level1)
362 {
363 int32_t ret;
364 int32_t channelId = 0;
365 int32_t fd = TEST_FD;
366 size_t len = BUF_LEN;
367
368 ret = TransClientGetTdcDataBufByChannel(channelId, nullptr, nullptr);
369 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
370
371 ret = TransClientGetTdcDataBufByChannel(channelId, &fd, &len);
372 EXPECT_EQ(SOFTBUS_TRANS_TDC_CHANNEL_NOT_FOUND, ret);
373
374 ret = TransDataListInit();
375 EXPECT_EQ(SOFTBUS_OK, ret);
376
377 ret = TransClientGetTdcDataBufByChannel(channelId, &fd, &len);
378 EXPECT_EQ(SOFTBUS_TRANS_TDC_CHANNEL_NOT_FOUND, ret);
379
380 ret = TransAddDataBufNode(channelId, fd);
381 EXPECT_EQ(SOFTBUS_OK, ret);
382
383 ret = TransClientGetTdcDataBufByChannel(channelId, &fd, &len);
384 EXPECT_EQ(SOFTBUS_OK, ret);
385
386 ret = TransDelDataBufNode(channelId);
387 EXPECT_EQ(SOFTBUS_OK, ret);
388
389 TransDataListDeinit();
390 }
391
392 /**
393 * @tc.name: TransClientUpdateTdcDataBufWInfoTest001
394 * @tc.desc: improve branch coverage, use the wrong or normal parameter.
395 * @tc.type: FUNC
396 * @tc.require:
397 */
398 HWTEST_F(TransTcpDirectTest, TransClientUpdateTdcDataBufWInfoTest001, TestSize.Level1)
399 {
400 int32_t ret;
401 int32_t channelId = 0;
402 int32_t fd = TEST_FD;
403 const char *recvBuf = RECV_BUF;
404 int32_t recvLen = MAX_LEN;
405
406 ret = TransClientUpdateTdcDataBufWInfo(channelId, nullptr, recvLen);
407 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
408
409 ret = TransClientUpdateTdcDataBufWInfo(channelId, const_cast<char *>(recvBuf), recvLen);
410 EXPECT_EQ(SOFTBUS_NO_INIT, ret);
411
412 ret = TransDataListInit();
413 EXPECT_EQ(SOFTBUS_OK, ret);
414
415 ret = TransClientUpdateTdcDataBufWInfo(channelId, const_cast<char *>(recvBuf), recvLen);
416 EXPECT_EQ(SOFTBUS_TRANS_TDC_CHANNEL_NOT_FOUND, ret);
417
418 ret = TransAddDataBufNode(channelId, fd);
419 EXPECT_EQ(SOFTBUS_OK, ret);
420
421 ret = TransClientUpdateTdcDataBufWInfo(channelId, const_cast<char *>(recvBuf), recvLen);
422 EXPECT_EQ(SOFTBUS_TRANS_INVALID_DATA_LENGTH, ret);
423
424 recvLen = strlen(recvBuf);
425 ret = TransClientUpdateTdcDataBufWInfo(channelId, const_cast<char *>(recvBuf), recvLen);
426 EXPECT_EQ(SOFTBUS_OK, ret);
427
428 ret = TransDelDataBufNode(channelId);
429 EXPECT_EQ(SOFTBUS_OK, ret);
430
431 TransDataListDeinit();
432 }
433
434 /**
435 * @tc.name: TransTdcRecvDataTest001
436 * @tc.desc: improve branch coverage, use the wrong or normal parameter.
437 * @tc.type: FUNC
438 * @tc.require:
439 */
440 HWTEST_F(TransTcpDirectTest, TransTdcRecvDataTest001, TestSize.Level1)
441 {
442 int32_t ret;
443 int32_t channelId = -1;
444 int32_t fd = -1;
445
446 ret = TransTdcRecvData(channelId);
447 EXPECT_EQ(SOFTBUS_NO_INIT, ret);
448
449 ret = TransDataListInit();
450 ASSERT_EQ(ret, SOFTBUS_OK);
451
452 channelId = 0;
453 ret = TransAddDataBufNode(channelId, fd);
454 ASSERT_EQ(ret, SOFTBUS_OK);
455
456 NiceMock<TransTcpDirectInterfaceMock> tcpDirectMock;
457 EXPECT_CALL(tcpDirectMock, GetErrCodeBySocketErr).WillOnce(Return(SOFTBUS_CONN_SOCKET_EINTR));
458 ret = TransTdcRecvData(channelId);
459 EXPECT_EQ(SOFTBUS_CONN_SOCKET_EINTR, ret);
460
461 EXPECT_CALL(tcpDirectMock, GetErrCodeBySocketErr).WillOnce(Return(SOFTBUS_CONN_BAD_FD));
462 ret = TransTdcRecvData(channelId);
463 EXPECT_EQ(SOFTBUS_CONN_BAD_FD, ret);
464
465 EXPECT_CALL(tcpDirectMock, GetErrCodeBySocketErr).WillOnce(Return(SOFTBUS_CONN_SOCKET_EAGAIN));
466 ret = TransTdcRecvData(channelId);
467 EXPECT_EQ(SOFTBUS_CONN_SOCKET_EAGAIN, ret);
468
469 EXPECT_CALL(tcpDirectMock, GetErrCodeBySocketErr).WillOnce(Return(SOFTBUS_CONN_SOCKET_ADDR_ERR));
470 ret = TransTdcRecvData(channelId);
471 EXPECT_EQ(SOFTBUS_CONN_SOCKET_ADDR_ERR, ret);
472
473 EXPECT_CALL(tcpDirectMock, GetErrCodeBySocketErr).WillOnce(Return(SOFTBUS_CONN_SOCKET_RESOURCE_BUSY));
474 ret = TransTdcRecvData(channelId);
475 EXPECT_EQ(SOFTBUS_CONN_SOCKET_RESOURCE_BUSY, ret);
476
477 EXPECT_CALL(tcpDirectMock, GetErrCodeBySocketErr).WillOnce(Return(SOFTBUS_CONN_SOCKET_INVALID_VARIABLE));
478 ret = TransTdcRecvData(channelId);
479 EXPECT_EQ(SOFTBUS_CONN_SOCKET_INVALID_VARIABLE, ret);
480
481 EXPECT_CALL(tcpDirectMock, GetErrCodeBySocketErr).WillOnce(Return(SOFTBUS_CONN_SOCKET_TOO_MUCH_FILE));
482 ret = TransTdcRecvData(channelId);
483 EXPECT_EQ(SOFTBUS_CONN_SOCKET_TOO_MUCH_FILE, ret);
484
485 EXPECT_CALL(tcpDirectMock, GetErrCodeBySocketErr).WillOnce(Return(SOFTBUS_CONN_SOCKET_FULL_FD));
486 ret = TransTdcRecvData(channelId);
487 EXPECT_EQ(SOFTBUS_CONN_SOCKET_FULL_FD, ret);
488
489 EXPECT_CALL(tcpDirectMock, GetErrCodeBySocketErr).WillOnce(Return(SOFTBUS_CONN_SOCKET_NO_SPACE_LEFT));
490 ret = TransTdcRecvData(channelId);
491 EXPECT_EQ(SOFTBUS_CONN_SOCKET_NO_SPACE_LEFT, ret);
492
493 EXPECT_CALL(tcpDirectMock, GetErrCodeBySocketErr).WillOnce(Return(SOFTBUS_CONN_SOCKET_PIPE_INTER));
494 ret = TransTdcRecvData(channelId);
495 EXPECT_EQ(SOFTBUS_CONN_SOCKET_PIPE_INTER, ret);
496
497 EXPECT_CALL(tcpDirectMock, GetErrCodeBySocketErr).WillOnce(Return(SOFTBUS_CONN_SOCKET_NOT_SOCKET));
498 ret = TransTdcRecvData(channelId);
499 EXPECT_EQ(SOFTBUS_CONN_SOCKET_NOT_SOCKET, ret);
500 testing::Mock::VerifyAndClearExpectations(&tcpDirectMock);
501
502 ret = TransDelDataBufNode(channelId);
503 EXPECT_EQ(SOFTBUS_OK, ret);
504
505 TransDataListDeinit();
506 }
507
508 /**
509 * @tc.name: TransTdcRecvDataTest001_1
510 * @tc.desc: improve branch coverage, use the wrong or normal parameter.
511 * @tc.type: FUNC
512 * @tc.require:
513 */
514 HWTEST_F(TransTcpDirectTest, TransTdcRecvDataTest001_1, TestSize.Level1)
515 {
516 int32_t ret;
517 int32_t channelId = -1;
518 int32_t fd = -1;
519
520 ret = TransDataListInit();
521 ASSERT_EQ(ret, SOFTBUS_OK);
522
523 channelId = 0;
524 ret = TransAddDataBufNode(channelId, fd);
525 ASSERT_EQ(ret, SOFTBUS_OK);
526
527 NiceMock<TransTcpDirectInterfaceMock> tcpDirectMock;
528 EXPECT_CALL(tcpDirectMock, GetErrCodeBySocketErr).WillOnce(Return(SOFTBUS_CONN_SOCKET_OPTION_UNKNOWN));
529 ret = TransTdcRecvData(channelId);
530 EXPECT_EQ(SOFTBUS_CONN_SOCKET_OPTION_UNKNOWN, ret);
531
532 EXPECT_CALL(tcpDirectMock, GetErrCodeBySocketErr).WillOnce(Return(SOFTBUS_CONN_SOCKET_ADDR_IN_USE));
533 ret = TransTdcRecvData(channelId);
534 EXPECT_EQ(SOFTBUS_CONN_SOCKET_ADDR_IN_USE, ret);
535
536 EXPECT_CALL(tcpDirectMock, GetErrCodeBySocketErr).WillOnce(Return(SOFTBUS_CONN_SOCKET_ADDR_NOT_AVAIL));
537 ret = TransTdcRecvData(channelId);
538 EXPECT_EQ(SOFTBUS_CONN_SOCKET_ADDR_NOT_AVAIL, ret);
539
540 EXPECT_CALL(tcpDirectMock, GetErrCodeBySocketErr).WillOnce(Return(SOFTBUS_CONN_SOCKET_NET_DOWN));
541 ret = TransTdcRecvData(channelId);
542 EXPECT_EQ(SOFTBUS_CONN_SOCKET_NET_DOWN, ret);
543
544 EXPECT_CALL(tcpDirectMock, GetErrCodeBySocketErr).WillOnce(Return(SOFTBUS_CONN_NET_REACH));
545 ret = TransTdcRecvData(channelId);
546 EXPECT_EQ(SOFTBUS_CONN_NET_REACH, ret);
547
548 EXPECT_CALL(tcpDirectMock, GetErrCodeBySocketErr).WillOnce(Return(SOFTBUS_CONN_SOCKET_NET_RESET));
549 ret = TransTdcRecvData(channelId);
550 EXPECT_EQ(SOFTBUS_CONN_SOCKET_NET_RESET, ret);
551
552 EXPECT_CALL(tcpDirectMock, GetErrCodeBySocketErr).WillOnce(Return(SOFTBUS_CONN_SOCKET_CONN_RESET));
553 ret = TransTdcRecvData(channelId);
554 EXPECT_EQ(SOFTBUS_CONN_SOCKET_CONN_RESET, ret);
555
556 EXPECT_CALL(tcpDirectMock, GetErrCodeBySocketErr).WillOnce(Return(SOFTBUS_CONN_SOCKET_NO_BUFS));
557 ret = TransTdcRecvData(channelId);
558 EXPECT_EQ(SOFTBUS_CONN_SOCKET_NO_BUFS, ret);
559
560 EXPECT_CALL(tcpDirectMock, GetErrCodeBySocketErr).WillOnce(Return(SOFTBUS_CONN_SOCKET_IS_CONN));
561 ret = TransTdcRecvData(channelId);
562 EXPECT_EQ(SOFTBUS_CONN_SOCKET_IS_CONN, ret);
563 testing::Mock::VerifyAndClearExpectations(&tcpDirectMock);
564
565 ret = TransDelDataBufNode(channelId);
566 EXPECT_EQ(SOFTBUS_OK, ret);
567
568 TransDataListDeinit();
569 }
570
571 /**
572 * @tc.name: TransTdcRecvDataTest001_2
573 * @tc.desc: improve branch coverage, use the wrong or normal parameter.
574 * @tc.type: FUNC
575 * @tc.require:
576 */
577 HWTEST_F(TransTcpDirectTest, TransTdcRecvDataTest001_2, TestSize.Level1)
578 {
579 int32_t ret;
580 int32_t channelId = -1;
581 int32_t fd = -1;
582
583 ret = TransDataListInit();
584 ASSERT_EQ(ret, SOFTBUS_OK);
585
586 channelId = 0;
587 ret = TransAddDataBufNode(channelId, fd);
588 ASSERT_EQ(ret, SOFTBUS_OK);
589
590 NiceMock<TransTcpDirectInterfaceMock> tcpDirectMock;
591 EXPECT_CALL(tcpDirectMock, GetErrCodeBySocketErr).WillOnce(Return(SOFTBUS_CONN_SOCKET_NOT_CONN));
592 ret = TransTdcRecvData(channelId);
593 EXPECT_EQ(SOFTBUS_CONN_SOCKET_NOT_CONN, ret);
594
595 EXPECT_CALL(tcpDirectMock, GetErrCodeBySocketErr).WillOnce(Return(SOFTBUS_CONN_SOCKET_TIME_OUT));
596 ret = TransTdcRecvData(channelId);
597 EXPECT_EQ(SOFTBUS_CONN_SOCKET_TIME_OUT, ret);
598
599 EXPECT_CALL(tcpDirectMock, GetErrCodeBySocketErr).WillOnce(Return(SOFTBUS_CONN_SOCKET_REFUSED));
600 ret = TransTdcRecvData(channelId);
601 EXPECT_EQ(SOFTBUS_CONN_SOCKET_REFUSED, ret);
602
603 EXPECT_CALL(tcpDirectMock, GetErrCodeBySocketErr).WillOnce(Return(SOFTBUS_CONN_SOCKET_HOST_DOWN));
604 ret = TransTdcRecvData(channelId);
605 EXPECT_EQ(SOFTBUS_CONN_SOCKET_HOST_DOWN, ret);
606
607 EXPECT_CALL(tcpDirectMock, GetErrCodeBySocketErr).WillOnce(Return(SOFTBUS_CONN_SOCKET_NO_ROUTE_AVALIABLE));
608 ret = TransTdcRecvData(channelId);
609 EXPECT_EQ(SOFTBUS_CONN_SOCKET_NO_ROUTE_AVALIABLE, ret);
610 testing::Mock::VerifyAndClearExpectations(&tcpDirectMock);
611
612 ret = TransDelDataBufNode(channelId);
613 EXPECT_EQ(SOFTBUS_OK, ret);
614
615 TransDataListDeinit();
616 }
617
618 /**
619 * @tc.name: TransTdcPackDataTest001
620 * @tc.desc: TransTdcPackData, use the wrong or normal parameter.
621 * @tc.type: FUNC
622 * @tc.require:
623 */
624 HWTEST_F(TransTcpDirectTest, TransTdcPackDataTest001, TestSize.Level1)
625 {
626 TcpDirectChannelInfo *channel = (TcpDirectChannelInfo *)SoftBusMalloc(sizeof(TcpDirectChannelInfo));
627 ASSERT_TRUE(channel != nullptr);
628 (void)memset_s(channel, sizeof(TcpDirectChannelInfo), 0, sizeof(TcpDirectChannelInfo));
629 channel->channelId = 1;
630 (void)memcpy_s(channel->detail.sessionKey, SESSIONKEY_LEN, g_sessionkey, strlen(g_sessionkey));
631 channel->detail.channelType = CHANNEL_TYPE_TCP_DIRECT;
632 channel->detail.fd = g_fd;
633 channel->detail.sequence = 1;
634 const char *data = "data";
635 uint32_t len = BUF_LEN;
636 int32_t flags = FLAG_ACK;
637 char *ret = TransTdcPackData(channel, data, len, flags, nullptr);
638 EXPECT_TRUE(ret == nullptr);
639 SoftBusFree(channel);
640 }
641
642 /**
643 * @tc.name: TransTdcProcessPostDataTest001
644 * @tc.desc: TransTdcProcessPostData, use the wrong or normal parameter.
645 * @tc.type: FUNC
646 * @tc.require:
647 */
648 HWTEST_F(TransTcpDirectTest, TransTdcProcessPostDataTest001, TestSize.Level1)
649 {
650 TcpDirectChannelInfo *channel = (TcpDirectChannelInfo *)SoftBusMalloc(sizeof(TcpDirectChannelInfo));
651 ASSERT_TRUE(channel != nullptr);
652 (void)memset_s(channel, sizeof(TcpDirectChannelInfo), 0, sizeof(TcpDirectChannelInfo));
653 channel->channelId = 1;
654 (void)memcpy_s(channel->detail.sessionKey, SESSIONKEY_LEN, g_sessionkey, strlen(g_sessionkey));
655 channel->detail.channelType = CHANNEL_TYPE_TCP_DIRECT;
656 channel->detail.fd = g_fd;
657 channel->detail.sequence = 1;
658 const char *data = "data";
659 uint32_t len = BUF_LEN;
660 int32_t flags = FLAG_ACK;
661 int32_t ret = TransTdcProcessPostData(channel, data, len, flags);
662 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
663 SoftBusFree(channel);
664 }
665
666 /**
667 * @tc.name: TransTdcDecryptTest001
668 * @tc.desc: TransTdcDecrypt, use the wrong or normal parameter.
669 * @tc.type: FUNC
670 * @tc.require:
671 */
672 HWTEST_F(TransTcpDirectTest, TransTdcDecryptTest001, TestSize.Level1)
673 {
674 char *out = nullptr;
675 uint32_t outLen = 0;
676 uint32_t inLen = 0;
677 int32_t ret = TransTdcDecrypt(nullptr, nullptr, inLen, out, &outLen);
678 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
679 }
680
681 /**
682 * @tc.name: TransTdcEncryptWithSeqTest001
683 * @tc.desc: TransTdcEncryptWithSeq, use the wrong or normal parameter.
684 * @tc.type: FUNC
685 * @tc.require:
686 */
687 HWTEST_F(TransTcpDirectTest, TransTdcEncryptWithSeqTest001, TestSize.Level1)
688 {
689 const char *in = "data";
690 char *out = nullptr;
691 uint32_t outLen = 0;
692 uint32_t inLen = (uint32_t)strlen(in);
693 int32_t seqNum = BUF_LEN;
694 EncrptyInfo enInfo = {
695 .in = in,
696 .inLen = inLen,
697 .out = out,
698 .outLen = &outLen,
699 };
700 int32_t ret = TransTdcEncryptWithSeq(nullptr, seqNum, &enInfo);
701 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
702
703 ret = TransTdcEncryptWithSeq(g_sessionkey, seqNum, nullptr);
704 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
705 }
706
707 /**
708 * @tc.name: TransTdcSetPendingPacketTest001
709 * @tc.desc: TransTdcSetPendingPacket, use the wrong or normal parameter.
710 * @tc.type: FUNC
711 * @tc.require:
712 */
713 HWTEST_F(TransTcpDirectTest, TransTdcSetPendingPacketTest001, TestSize.Level1)
714 {
715 int32_t channelId = 1;
716 const char *data = "data";
717 uint32_t len = 0;
718 int32_t seqNum = 1;
719 int32_t type = 1;
720 int32_t ret = TransTdcSetPendingPacket(channelId, data, len, 0);
721 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
722 ret = PendingInit(type);
723 EXPECT_EQ(ret, SOFTBUS_OK);
724
725 ret = ProcPendingPacket(channelId, seqNum, type);
726 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
727 len = ACK_SIZE;
728 channelId = INVALID_VALUE;
729 ret = TransTdcSetPendingPacket(channelId, data, len, 0);
730 EXPECT_EQ(SOFTBUS_TRANS_NODE_NOT_FOUND, ret);
731 channelId = 1;
732 ret = TransTdcSetPendingPacket(channelId, data, len, 0);
733 EXPECT_EQ(SOFTBUS_TRANS_NODE_NOT_FOUND, ret);
734 PendingDeinit(type);
735 }
736
737 /**
738 * @tc.name: TransTdcSendAckTest001
739 * @tc.desc: TransTdcSendAck, use the wrong or normal parameter.
740 * @tc.type: FUNC
741 * @tc.require:
742 */
743 HWTEST_F(TransTcpDirectTest, TransTdcSendAckTest001, TestSize.Level1)
744 {
745 int32_t seq = 1;
746 int32_t channelId = -1;
747 int32_t ret = TransTdcSendAck(channelId, seq);
748 EXPECT_EQ(ret, SOFTBUS_TRANS_TDC_GET_INFO_FAILED);
749 }
750
751 /**
752 * @tc.name: TransGetDataBufSizeTest001
753 * @tc.desc: TransGetDataBufSize, use the wrong or normal parameter.
754 * @tc.type: FUNC
755 * @tc.require:
756 */
757 HWTEST_F(TransTcpDirectTest, TransGetDataBufSizeTest001, TestSize.Level1)
758 {
759 uint32_t ret = TransGetDataBufSize();
760 EXPECT_EQ(ret, MIN_BUF_LEN);
761
762 int32_t res = TransGetTdcDataBufMaxSize();
763 EXPECT_EQ(res, SOFTBUS_OK);
764 }
765
766 /**
767 * @tc.name: TransDestroyDataBufTest001
768 * @tc.desc: TransDestroyDataBuf, use the wrong or normal parameter.
769 * @tc.type: FUNC
770 * @tc.require:
771 */
772 HWTEST_F(TransTcpDirectTest, TransDestroyDataBufTest001, TestSize.Level1)
773 {
774 int32_t channelId = 1;
775 int32_t fd = TEST_FD;
776 int32_t ret = TransDestroyDataBuf();
777 EXPECT_EQ(ret, SOFTBUS_NO_INIT);
778
779 ret = TransDataListInit();
780 ASSERT_EQ(ret, SOFTBUS_OK);
781
782 ret = TransAddDataBufNode(channelId, fd);
783 ASSERT_EQ(ret, SOFTBUS_OK);
784
785 ret = TransDestroyDataBuf();
786 EXPECT_EQ(ret, SOFTBUS_OK);
787 TransDataListDeinit();
788 }
789
790 /**
791 * @tc.name: TransGetDataBufNodeByIdTest001
792 * @tc.desc: TransGetDataBufNodeById, use the wrong or normal parameter.
793 * @tc.type: FUNC
794 * @tc.require:
795 */
796 HWTEST_F(TransTcpDirectTest, TransGetDataBufNodeByIdTest001, TestSize.Level1)
797 {
798 int32_t channelId = 1;
799 int32_t fd = TEST_FD;
800 DataBuf *data = TransGetDataBufNodeById(channelId);
801 EXPECT_TRUE(data == nullptr);
802
803 int32_t ret = TransDataListInit();
804 ASSERT_EQ(ret, SOFTBUS_OK);
805
806 ret = TransAddDataBufNode(channelId, fd);
807 ASSERT_EQ(ret, SOFTBUS_OK);
808
809 data = TransGetDataBufNodeById(channelId);
810 EXPECT_TRUE(data != nullptr);
811
812 TransDataListDeinit();
813 }
814
815 /**
816 * @tc.name: TransTdcProcessDataByFlagTest001
817 * @tc.desc: TransTdcProcessDataByFlag, use the wrong or normal parameter.
818 * @tc.type: FUNC
819 * @tc.require:
820 */
821 HWTEST_F(TransTcpDirectTest, TransTdcProcessDataByFlagTest001, TestSize.Level1)
822 {
823 uint32_t flag = FLAG_BYTES;
824 int32_t seqNum = 1;
825 const char *plain = "plain";
826 uint32_t plainLen = 0;
827 flag = FLAG_ACK;
828 int32_t ret = TransTdcProcessDataByFlag(flag, seqNum, nullptr, plain, plainLen);
829 EXPECT_EQ(ret, SOFTBUS_OK);
830 }
831
832 /**
833 * @tc.name: TransTdcProcessDataTest001
834 * @tc.desc: TransTdcProcessData, use the wrong or normal parameter.
835 * @tc.type: FUNC
836 * @tc.require:
837 */
838 HWTEST_F(TransTcpDirectTest, TransTdcProcessDataTest001, TestSize.Level1)
839 {
840 int32_t channelId = 1;
841 int32_t fd = TEST_FD;
842 ChannelInfo *info = (ChannelInfo *)SoftBusCalloc(sizeof(ChannelInfo));
843 ASSERT_TRUE(info != nullptr);
844 info->peerSessionName = (char *)g_sessionName;
845 info->channelId = 1;
846 info->channelType = CHANNEL_TYPE_TCP_DIRECT;
847 info->sessionKey = (char *)g_sessionkey;
848 info->fd = g_fd;
849
850 int32_t ret = TransTdcProcessData(channelId);
851 EXPECT_EQ(SOFTBUS_TRANS_TDC_CHANNEL_NOT_FOUND, ret);
852 IClientSessionCallBack *cb = GetClientSessionCb();
853 ret = TransTdcManagerInit(cb);
854 ASSERT_EQ(ret, SOFTBUS_OK);
855
856 ret = TransTdcProcessData(channelId);
857 EXPECT_EQ(SOFTBUS_TRANS_TDC_CHANNEL_NOT_FOUND, ret);
858
859 ret = TransDataListInit();
860 ASSERT_EQ(ret, SOFTBUS_OK);
861
862 ret = TransAddDataBufNode(channelId, fd);
863 ASSERT_EQ(ret, SOFTBUS_OK);
864
865 ret = TransTdcProcessData(channelId);
866 EXPECT_NE(SOFTBUS_OK, ret);
867
868 TransDataListDeinit();
869 TransTdcManagerDeinit();
870 SoftBusFree(info);
871 }
872
873 /**
874 * @tc.name: TransResizeDataBufferTest001
875 * @tc.desc: TransResizeDataBuffer, use the wrong or normal parameter.
876 * @tc.type: FUNC
877 * @tc.require:
878 */
879 HWTEST_F(TransTcpDirectTest, TransResizeDataBufferTest001, TestSize.Level1)
880 {
881 DataBuf *oldBuf = (DataBuf *)SoftBusCalloc(sizeof(DataBuf));
882 ASSERT_TRUE(oldBuf != nullptr);
883 (void)memset_s(oldBuf, sizeof(DataBuf), 0, sizeof(DataBuf));
884 int32_t ret = TransResizeDataBuffer(oldBuf, PKG_LEN);
885 EXPECT_EQ(ret, SOFTBUS_MEM_ERR);
886
887 (void)memcpy_s(oldBuf->data, strlen("data"), "data", strlen("data"));
888 oldBuf->size = BUF_LEN;
889 (void)memcpy_s(oldBuf->w, strlen("oldbulf"), "oldbulf", strlen("oldbulf"));
890
891 ret = TransResizeDataBuffer(oldBuf, PKG_LEN);
892 EXPECT_EQ(ret, SOFTBUS_MEM_ERR);
893 SoftBusFree(oldBuf);
894 }
895
896 /**
897 * @tc.name: TransTdcProcAllDataTest001
898 * @tc.desc: TransTdcProcAllData, use the wrong or normal parameter.
899 * @tc.type: FUNC
900 * @tc.require:
901 */
902 HWTEST_F(TransTcpDirectTest, TransTdcProcAllDataTest001, TestSize.Level1)
903 {
904 int32_t channelId = 1;
905 int32_t fd = TEST_FD;
906 DataBuf *oldBuf = (DataBuf *)SoftBusCalloc(sizeof(DataBuf));
907 ASSERT_TRUE(oldBuf != nullptr);
908 (void)memset_s(oldBuf, sizeof(DataBuf), 0, sizeof(DataBuf));
909
910 int32_t ret = TransTdcProcAllData(channelId);
911 EXPECT_EQ(ret, SOFTBUS_NO_INIT);
912
913 ret = TransDataListInit();
914 ASSERT_EQ(ret, SOFTBUS_OK);
915
916 ret = TransAddDataBufNode(channelId, fd);
917 ASSERT_EQ(ret, SOFTBUS_OK);
918
919 ret = TransTdcProcAllData(channelId);
920 EXPECT_EQ(ret, SOFTBUS_OK);
921 TransDataListDeinit();
922 SoftBusFree(oldBuf);
923 }
924
925 /**
926 * @tc.name: ClientTdcOnConnectEventTest001
927 * @tc.desc: ClientTdcOnConnectEvent, use the wrong or normal parameter.
928 * @tc.type: FUNC
929 * @tc.require:
930 */
931 HWTEST_F(TransTcpDirectTest, ClientTdcOnConnectEventTest001, TestSize.Level1)
932 {
933 int32_t cfd = 0;
934 int32_t ret = ClientTdcOnConnectEvent(DIRECT_CHANNEL_SERVER_WIFI, cfd, nullptr);
935 EXPECT_EQ(ret, SOFTBUS_OK);
936 }
937
938 /**
939 * @tc.name: ClientTdcOnDataEventTest001
940 * @tc.desc: ClientTdcOnDataEvent, use the wrong or normal parameter.
941 * @tc.type: FUNC
942 * @tc.require:
943 */
944 HWTEST_F(TransTcpDirectTest, ClientTdcOnDataEventTest001, TestSize.Level1)
945 {
946 int32_t events = SOFTBUS_SOCKET_IN;
947 int32_t fd = g_fd;
948 ChannelInfo *info = (ChannelInfo *)SoftBusCalloc(sizeof(ChannelInfo));
949 ASSERT_TRUE(info != nullptr);
950 (void)memset_s(info, sizeof(ChannelInfo), 0, sizeof(ChannelInfo));
951 info->peerSessionName = (char *)g_sessionName;
952 info->channelId = 1;
953 info->channelType = CHANNEL_TYPE_TCP_DIRECT;
954 info->sessionKey = (char *)g_sessionkey;
955 info->fd = g_fd;
956 IClientSessionCallBack *cb = GetClientSessionCb();
957 int32_t ret = TransTdcManagerInit(cb);
958 ASSERT_EQ(ret, SOFTBUS_OK);
959
960 ret = ClientTdcOnDataEvent(DIRECT_CHANNEL_SERVER_WIFI, events, fd);
961 EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
962 }
963
964 /**
965 * @tc.name: TransGetNewTcpChannelTest001
966 * @tc.desc: TransGetNewTcpChannel, use the wrong or normal parameter.
967 * @tc.type: FUNC
968 * @tc.require:
969 */
970 HWTEST_F(TransTcpDirectTest, TransGetNewTcpChannelTest001, TestSize.Level1)
971 {
972 int32_t channelId = 1;
973 TcpDirectChannelInfo *info = TransGetNewTcpChannel(nullptr);
974 ASSERT_EQ(info, nullptr);
975 ChannelInfo *channelInfo = (ChannelInfo *)SoftBusCalloc(sizeof(ChannelInfo));
976 ASSERT_TRUE(channelInfo != nullptr);
977 (void)memset_s(channelInfo, sizeof(ChannelInfo), 0, sizeof(ChannelInfo));
978 channelInfo->peerSessionName = (char *)g_sessionName;
979 channelInfo->channelId = 1;
980 channelInfo->channelType = CHANNEL_TYPE_TCP_DIRECT;
981 channelInfo->sessionKey = (char *)g_sessionkey;
982 channelInfo->fd = g_fd;
983
984 IClientSessionCallBack *cb = GetClientSessionCb();
985 int32_t ret = TransTdcManagerInit(cb);
986 ASSERT_EQ(ret, SOFTBUS_OK);
987
988 ret = ClientTransCheckTdcChannelExist(channelId);
989 EXPECT_EQ(ret, SOFTBUS_OK);
990 SoftBusFree(channelInfo);
991 }
992
993 /**
994 * @tc.name: TransTdcProcessDataByFlagTest002
995 * @tc.desc: TransTdcProcessDataByFlag, use different parameters.
996 * @tc.type: FUNC
997 * @tc.require:
998 */
999 HWTEST_F(TransTcpDirectTest, TransTdcProcessDataByFlagTest002, TestSize.Level1)
1000 {
1001 TcpDirectChannelInfo *channel = (TcpDirectChannelInfo *)SoftBusCalloc(sizeof(TcpDirectChannelInfo));
1002 ASSERT_TRUE(channel != nullptr);
1003
1004 int32_t ret = memcpy_s(channel->detail.sessionKey, SESSIONKEY_LEN, g_sessionkey, strlen(g_sessionkey));
1005 ASSERT_EQ(ret, EOK);
1006 channel->channelId = TRANS_TEST_CHANNEL_ID;
1007 channel->detail.channelType = CHANNEL_TYPE_TCP_DIRECT;
1008 channel->detail.fd = TRANS_TEST_FD;
1009 channel->detail.sequence = 1;
1010 int32_t seqNum = 1;
1011 const char *plain = "plain";
1012
1013 ret = TransTdcProcessDataByFlag(FLAG_BYTES, seqNum, channel, plain, (uint32_t)strlen(plain));
1014 EXPECT_NE(ret, SOFTBUS_OK);
1015
1016 ret = TransTdcProcessDataByFlag(FLAG_ACK, seqNum, channel, plain, (uint32_t)strlen(plain));
1017 EXPECT_EQ(ret, SOFTBUS_OK);
1018
1019 ret = TransTdcProcessDataByFlag(FLAG_MESSAGE, seqNum, channel, plain, (uint32_t)strlen(plain));
1020 EXPECT_NE(ret, SOFTBUS_OK);
1021
1022 ret = TransTdcProcessDataByFlag(FILE_FIRST_FRAME, seqNum, channel, plain, (uint32_t)strlen(plain));
1023 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1024
1025 SoftBusFree(channel);
1026 }
1027
1028 /**
1029 * @tc.name: TransTdcProcAllDataTest002
1030 * @tc.desc: TransTdcProcAllData, use different parameters.
1031 * @tc.type: FUNC
1032 * @tc.require:
1033 */
1034 HWTEST_F(TransTcpDirectTest, TransTdcProcAllDataTest002, TestSize.Level1)
1035 {
1036 int32_t ret = TransDataListInit();
1037 ASSERT_EQ(ret, SOFTBUS_OK);
1038
1039 ret = TransAddDataBufNode(TRANS_TEST_CHANNEL_ID, TRANS_TEST_FD);
1040 ASSERT_EQ(ret, SOFTBUS_OK);
1041 ret = TransTdcProcAllData(TRANS_TEST_CHANNEL_ID);
1042 EXPECT_EQ(ret, SOFTBUS_OK);
1043
1044 TransDataListDeinit();
1045 }
1046
1047 /**
1048 * @tc.name: TransTdcDecryptTest002
1049 * @tc.desc: TransTdcDecrypt, use different parameters.
1050 * @tc.type: FUNC
1051 * @tc.require:
1052 */
1053 HWTEST_F(TransTcpDirectTest, TransTdcDecryptTest002, TestSize.Level1)
1054 {
1055 char output[MAX_LEN] = {0};
1056 uint32_t outLen = MAX_LEN;
1057 int32_t ret = TransTdcDecrypt(g_sessionkey, RECV_BUF, strlen(RECV_BUF) + 1, output, &outLen);
1058 EXPECT_FALSE(ret == SOFTBUS_OK);
1059 }
1060
1061 /**
1062 * @tc.name: ClientTransTdcOnChannelOpenedTest001
1063 * @tc.desc: ClientTransTdcOnChannelOpened, use the wrong or normal parameter.
1064 * @tc.type: FUNC
1065 * @tc.require:
1066 */
1067 HWTEST_F(TransTcpDirectTest, ClientTransTdcOnChannelOpenedTest001, TestSize.Level1)
1068 {
1069 ChannelInfo *info = (ChannelInfo *)SoftBusCalloc(sizeof(ChannelInfo));
1070 ASSERT_TRUE(info != nullptr);
1071 info->peerSessionName = (char *)g_sessionName;
1072 info->channelId = 1;
1073 info->channelType = CHANNEL_TYPE_TCP_DIRECT;
1074 info->sessionKey = (char *)g_sessionkey;
1075 info->fd = g_fd;
1076 int32_t ret = ClientTransTdcOnChannelOpened(g_sessionName, info, nullptr);
1077 EXPECT_EQ(ret, SOFTBUS_MEM_ERR);
1078 SoftBusFree(info);
1079 }
1080
1081 /**
1082 * @tc.name: ClientTdcOnDataEventTest002
1083 * @tc.desc: ClientTdcOnDataEvent, use the wrong or normal parameter.
1084 * @tc.type: FUNC
1085 * @tc.require:
1086 */
1087 HWTEST_F(TransTcpDirectTest, ClientTdcOnDataEventTest002, TestSize.Level1)
1088 {
1089 int32_t events = SOFTBUS_SOCKET_OUT;
1090 int32_t channelId = 1;
1091 TcpDirectChannelInfo *info = reinterpret_cast<TcpDirectChannelInfo *>(SoftBusCalloc(sizeof(TcpDirectChannelInfo)));
1092 ASSERT_NE(info, nullptr);
1093
1094 g_tcpDirectChannelInfoList = CreateSoftBusList();
1095 ASSERT_NE(g_tcpDirectChannelInfoList, nullptr);
1096
1097 info->channelId = channelId;
1098 info->detail.fd = g_fd;
1099
1100 (void)SoftBusMutexLock(&g_tcpDirectChannelInfoList->lock);
1101 ListAdd(&g_tcpDirectChannelInfoList->list, &info->node);
1102 (void)SoftBusMutexUnlock(&g_tcpDirectChannelInfoList->lock);
1103
1104 int32_t ret = ClientTdcOnDataEvent(DIRECT_CHANNEL_SERVER_WIFI, events, g_fd);
1105 EXPECT_EQ(ret, SOFTBUS_OK);
1106
1107 events = SOFTBUS_SOCKET_EXCEPTION;
1108 ret = ClientTdcOnDataEvent(DIRECT_CHANNEL_SERVER_WIFI, events, g_fd);
1109 EXPECT_EQ(ret, SOFTBUS_OK);
1110 // info is deleted in the abnormal branch
1111 DestroySoftBusList(g_tcpDirectChannelInfoList);
1112 g_tcpDirectChannelInfoList = nullptr;
1113 }
1114
1115 /**
1116 * @tc.name: TransTdcCreateListenerWithoutAddTriggerTest001
1117 * @tc.desc: TransTdcCreateListenerWithoutAddTrigger, use the wrong or normal parameter.
1118 * @tc.type: FUNC
1119 * @tc.require:
1120 */
1121 HWTEST_F(TransTcpDirectTest, TransTdcCreateListenerWithoutAddTriggerTest001, TestSize.Level1)
1122 {
1123 g_isInitedFlag = true;
1124 int32_t fd = g_fd;
1125
1126 int32_t ret = TransTdcCreateListenerWithoutAddTrigger(fd);
1127 EXPECT_EQ(ret, SOFTBUS_OK);
1128
1129 g_isInitedFlag = false;
1130 ret = TransTdcCreateListenerWithoutAddTrigger(fd);
1131 EXPECT_EQ(ret, SOFTBUS_OK);
1132 }
1133
1134 /**
1135 * @tc.name: TransTdcCloseFdTest001
1136 * @tc.desc: TransTdcCloseFd, use the wrong or normal parameter.
1137 * @tc.type: FUNC
1138 * @tc.require:
1139 */
1140 HWTEST_F(TransTcpDirectTest, TransTdcCloseFdTest001, TestSize.Level1)
1141 {
1142 int32_t fd = -1;
1143 TransTdcCloseFd(fd);
1144 fd = 1000000;
1145 NiceMock<TransTcpDirectInterfaceMock> tcpDirectMock;
1146 EXPECT_CALL(tcpDirectMock, SoftBusSocketGetError).WillOnce(Return(SOFTBUS_CONN_BAD_FD));
1147 TransTdcCloseFd(fd);
1148 testing::Mock::VerifyAndClearExpectations(&tcpDirectMock);
1149 fd = g_fd;
1150 TransTdcCloseFd(fd);
1151 EXPECT_TRUE(fd);
1152 }
1153
1154 /**
1155 * @tc.name: UnPackTcpDataPacketHeadTest001
1156 * @tc.desc: UnPackTcpDataPacketHead, use the wrong or normal parameter.
1157 * @tc.type: FUNC
1158 * @tc.require:
1159 */
1160 HWTEST_F(TransTcpDirectTest, UnPackTcpDataPacketHeadTest001, TestSize.Level1)
1161 {
1162 TcpDataPacketHead data;
1163 data.seq = 1;
1164 UnPackTcpDataPacketHead(&data);
1165 EXPECT_TRUE(data.seq);
1166 }
1167
1168 /**
1169 * @tc.name: CheckCollaborationSessionNameTest001
1170 * @tc.desc: CheckCollaborationSessionName, use the wrong or normal parameter.
1171 * @tc.type: FUNC
1172 * @tc.require:
1173 */
1174 HWTEST_F(TransTcpDirectTest, CheckCollaborationSessionNameTest001, TestSize.Level1)
1175 {
1176 const char *testSessionName = "ohos.collaborationcenter";
1177 bool ret = CheckCollaborationSessionName(testSessionName);
1178 EXPECT_EQ(ret, true);
1179 const char *testSessionName1 = "nullptr";
1180 ret = CheckCollaborationSessionName(testSessionName1);
1181 EXPECT_EQ(ret, false);
1182 }
1183
1184 /**
1185 * @tc.name: TransTdcProcessPostDataTest002
1186 * @tc.desc: TransTdcProcessPostData, use the wrong or normal parameter.
1187 * @tc.type: FUNC
1188 * @tc.require:
1189 */
1190 HWTEST_F(TransTcpDirectTest, TransTdcProcessPostDataTest002, TestSize.Level1)
1191 {
1192 int32_t channelId = 1;
1193 ChannelType channelType = CHANNEL_TYPE_TCP_DIRECT;
1194 const char *data = "data";
1195 uint32_t len = BUF_LEN;
1196 int32_t flags = FLAG_ACK;
1197
1198 TcpDirectChannelInfo *channel = reinterpret_cast<TcpDirectChannelInfo *>(
1199 SoftBusCalloc(sizeof(TcpDirectChannelInfo)));
1200 ASSERT_TRUE(channel != nullptr);
1201 channel->channelId = channelId;
1202 channel->detail.channelType = channelType;
1203
1204 ClientSessionServer *serverNode = reinterpret_cast<ClientSessionServer *>(
1205 SoftBusCalloc(sizeof(ClientSessionServer)));
1206 ASSERT_NE(serverNode, nullptr);
1207
1208 SessionInfo *info = reinterpret_cast<SessionInfo *>(SoftBusCalloc(sizeof(SessionInfo)));
1209 ASSERT_NE(info, nullptr);
1210 info->channelId = channelId;
1211 info->channelType = channelType;
1212 ListInit(&serverNode->sessionList);
1213 ListAdd(&serverNode->sessionList, &info->node);
1214
1215 g_tcpDirectChannelInfoList = CreateSoftBusList();
1216 ASSERT_NE(g_tcpDirectChannelInfoList, nullptr);
1217 (void)SoftBusMutexLock(&g_tcpDirectChannelInfoList->lock);
1218 ListAdd(&g_tcpDirectChannelInfoList->list, &serverNode->node);
1219 (void)SoftBusMutexUnlock(&g_tcpDirectChannelInfoList->lock);
1220
1221 int32_t ret = TransTdcProcessPostData(channel, data, len, flags);
1222 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
1223 SoftBusFree(channel);
1224 SoftBusFree(info);
1225 SoftBusFree(serverNode);
1226 DestroySoftBusList(g_tcpDirectChannelInfoList);
1227 g_tcpDirectChannelInfoList = nullptr;
1228 }
1229
1230 /**
1231 * @tc.name: TransTdcSendBytesTest001
1232 * @tc.desc: TransTdcSendBytes, use the wrong or normal parameter.
1233 * @tc.type: FUNC
1234 * @tc.require:
1235 */
1236 HWTEST_F(TransTcpDirectTest, TransTdcSendBytesTest001, TestSize.Level1)
1237 {
1238 int32_t channelId = 1;
1239 const char *data = "data";
1240 uint32_t len = BUF_LEN;
1241 TcpDirectChannelInfo *info = reinterpret_cast<TcpDirectChannelInfo *>(SoftBusCalloc(sizeof(TcpDirectChannelInfo)));
1242 ASSERT_NE(info, nullptr);
1243 g_tcpDirectChannelInfoList = CreateSoftBusList();
1244 ASSERT_NE(g_tcpDirectChannelInfoList, nullptr);
1245 NiceMock<TransTcpDirectInterfaceMock> tcpDirectMock;
1246 EXPECT_CALL(tcpDirectMock, SoftBusSocketGetError).WillRepeatedly(Return(SOFTBUS_CONN_BAD_FD));
1247
1248 info->channelId = channelId;
1249 info->detail.needRelease = true;
1250 (void)SoftBusMutexLock(&g_tcpDirectChannelInfoList->lock);
1251 ListAdd(&g_tcpDirectChannelInfoList->list, &info->node);
1252 (void)SoftBusMutexUnlock(&g_tcpDirectChannelInfoList->lock);
1253
1254 int32_t ret = TransTdcSendBytes(channelId, data, len, false);
1255 EXPECT_EQ(ret, SOFTBUS_TRANS_TDC_CHANNEL_CLOSED_BY_ANOTHER_THREAD);
1256
1257 info->detail.needRelease = false;
1258 ret = TransTdcSendBytes(channelId, data, len, false);
1259 EXPECT_EQ(ret, SOFTBUS_TRANS_TDC_GET_INFO_FAILED);
1260 DestroySoftBusList(g_tcpDirectChannelInfoList);
1261 g_tcpDirectChannelInfoList = nullptr;
1262 }
1263
1264 /**
1265 * @tc.name: TransTdcSendMessageTest001
1266 * @tc.desc: TransTdcSendMessage, use the wrong or normal parameter.
1267 * @tc.type: FUNC
1268 * @tc.require:
1269 */
1270 HWTEST_F(TransTcpDirectTest, TransTdcSendMessageTest001, TestSize.Level1)
1271 {
1272 int32_t channelId = 1;
1273 uint32_t len = BUF_LEN;
1274 const char *data = "data";
1275 TcpDirectChannelInfo *info = reinterpret_cast<TcpDirectChannelInfo *>(SoftBusCalloc(sizeof(TcpDirectChannelInfo)));
1276 ASSERT_NE(info, nullptr);
1277 g_tcpDirectChannelInfoList = CreateSoftBusList();
1278 ASSERT_NE(g_tcpDirectChannelInfoList, nullptr);
1279 info->channelId = channelId;
1280 info->detail.needRelease = true;
1281
1282 (void)SoftBusMutexLock(&g_tcpDirectChannelInfoList->lock);
1283 ListAdd(&g_tcpDirectChannelInfoList->list, &info->node);
1284 (void)SoftBusMutexUnlock(&g_tcpDirectChannelInfoList->lock);
1285
1286 int32_t ret = TransTdcSendMessage(channelId, data, len);
1287 EXPECT_EQ(ret, SOFTBUS_TRANS_TDC_CHANNEL_CLOSED_BY_ANOTHER_THREAD);
1288
1289 info->detail.needRelease = false;
1290 ret = TransTdcSendMessage(channelId, data, len);
1291 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
1292 SoftBusFree(info);
1293 DestroySoftBusList(g_tcpDirectChannelInfoList);
1294 g_tcpDirectChannelInfoList = nullptr;
1295 }
1296
1297 /**
1298 * @tc.name: TransTdcProcessDataTest002
1299 * @tc.desc: TransTdcProcessData, use the wrong or normal parameter.
1300 * @tc.type: FUNC
1301 * @tc.require:
1302 */
1303 HWTEST_F(TransTcpDirectTest, TransTdcProcessDataTest002, TestSize.Level1)
1304 {
1305 int32_t channelId = 1;
1306 int32_t ret = TransTdcProcessData(channelId);
1307 EXPECT_EQ(SOFTBUS_TRANS_TDC_CHANNEL_NOT_FOUND, ret);
1308
1309 TcpDirectChannelInfo *info = reinterpret_cast<TcpDirectChannelInfo *>(SoftBusCalloc(sizeof(TcpDirectChannelInfo)));
1310 ASSERT_NE(info, nullptr);
1311 g_tcpDirectChannelInfoList = CreateSoftBusList();
1312 ASSERT_NE(g_tcpDirectChannelInfoList, nullptr);
1313 info->channelId = channelId;
1314 (void)SoftBusMutexLock(&g_tcpDirectChannelInfoList->lock);
1315 ListAdd(&g_tcpDirectChannelInfoList->list, &info->node);
1316 (void)SoftBusMutexUnlock(&g_tcpDirectChannelInfoList->lock);
1317
1318 ret = TransTdcProcessData(channelId);
1319 EXPECT_EQ(SOFTBUS_LOCK_ERR, ret);
1320
1321 DataBuf *buf = reinterpret_cast<DataBuf *>(SoftBusCalloc(sizeof(DataBuf)));
1322 ASSERT_NE(buf, nullptr);
1323 g_tcpDataList = CreateSoftBusList();
1324 ASSERT_NE(g_tcpDataList, nullptr);
1325 ret = TransTdcProcessData(channelId);
1326 EXPECT_EQ(SOFTBUS_TRANS_NODE_NOT_FOUND, ret);
1327
1328 TcpDataPacketHead *pktHead = reinterpret_cast<TcpDataPacketHead *>(SoftBusCalloc(sizeof(TcpDataPacketHead)));
1329 ASSERT_NE(pktHead, nullptr);
1330 pktHead->dataLen = 0;
1331 pktHead->seq = 0;
1332 pktHead->flags = 0;
1333 buf->data = (char*)pktHead;
1334 buf->channelId = channelId;
1335 (void)SoftBusMutexLock(&g_tcpDataList->lock);
1336 ListAdd(&g_tcpDataList->list, &buf->node);
1337 (void)SoftBusMutexUnlock(&g_tcpDataList->lock);
1338
1339 ret = TransTdcProcessData(channelId);
1340 EXPECT_EQ(SOFTBUS_MALLOC_ERR, ret);
1341
1342 IClientSessionCallBack *cb = GetClientSessionCb();
1343 ret = TransTdcManagerInit(cb);
1344 ASSERT_EQ(ret, SOFTBUS_OK);
1345
1346 ret = TransTdcProcessData(channelId);
1347 EXPECT_NE(SOFTBUS_OK, ret);
1348 // pktHead is deleted in the abnormal branch
1349 SoftBusFree(info);
1350 SoftBusFree(buf);
1351 DestroySoftBusList(g_tcpDirectChannelInfoList);
1352 DestroySoftBusList(g_tcpDataList);
1353 g_tcpDirectChannelInfoList = nullptr;
1354 g_tcpDataList = nullptr;
1355 }
1356
1357 /**
1358 * @tc.name: TransTdcProcAllDataTest003
1359 * @tc.desc: TransTdcProcAllData, use different parameters.
1360 * @tc.type: FUNC
1361 * @tc.require:
1362 */
1363 HWTEST_F(TransTcpDirectTest, TransTdcProcAllDataTest003, TestSize.Level1)
1364 {
1365 int32_t ret = TransTdcProcAllData(TRANS_TEST_CHANNEL_ID);;
1366 EXPECT_EQ(ret, SOFTBUS_NO_INIT);
1367
1368 DataBuf *buf = reinterpret_cast<DataBuf *>(SoftBusCalloc(sizeof(DataBuf)));
1369 ASSERT_NE(buf, nullptr);
1370 g_tcpDataList = CreateSoftBusList();
1371 ASSERT_NE(g_tcpDataList, nullptr);
1372
1373 ret = TransTdcProcAllData(TRANS_TEST_CHANNEL_ID);;
1374 EXPECT_EQ(ret, SOFTBUS_TRANS_NODE_NOT_FOUND);
1375
1376 char testData[] = "data";
1377 buf->channelId = TRANS_TEST_CHANNEL_ID;
1378 buf->data = testData;
1379 buf->w = testData;
1380 (void)SoftBusMutexLock(&g_tcpDataList->lock);
1381 ListAdd(&g_tcpDataList->list, &buf->node);
1382 (void)SoftBusMutexUnlock(&g_tcpDataList->lock);
1383
1384 ret = TransTdcProcAllData(TRANS_TEST_CHANNEL_ID);
1385 EXPECT_EQ(ret, SOFTBUS_OK);
1386
1387 SoftBusFree(buf);
1388 DestroySoftBusList(g_tcpDataList);
1389 g_tcpDataList = nullptr;
1390 }
1391
1392 /**
1393 * @tc.name: TransTdcProcAllDataTest004
1394 * @tc.desc: TransTdcProcAllData, use different parameters.
1395 * @tc.type: FUNC
1396 * @tc.require:
1397 */
1398 HWTEST_F(TransTcpDirectTest, TransTdcProcAllDataTest004, TestSize.Level1)
1399 {
1400 int32_t channelId = TRANS_TEST_CHANNEL_ID;
1401 DataBuf *buf = reinterpret_cast<DataBuf *>(SoftBusCalloc(sizeof(DataBuf)));
1402 ASSERT_NE(buf, nullptr);
1403 g_tcpDataList = CreateSoftBusList();
1404 ASSERT_NE(g_tcpDataList, nullptr);
1405
1406 TcpDataPacketHead *pktHead = reinterpret_cast<TcpDataPacketHead *>(SoftBusCalloc(sizeof(TcpDataPacketHead)));
1407 ASSERT_NE(pktHead, nullptr);
1408 pktHead->magicNumber = 0x01;
1409 buf->channelId = channelId;
1410 buf->data = (char *)pktHead;
1411 buf->w = buf->data + DC_DATA_HEAD_SIZE - 1;
1412 (void)SoftBusMutexLock(&g_tcpDataList->lock);
1413 ListAdd(&g_tcpDataList->list, &buf->node);
1414 (void)SoftBusMutexUnlock(&g_tcpDataList->lock);
1415
1416 int32_t ret = TransTdcProcAllData(TRANS_TEST_CHANNEL_ID);
1417 EXPECT_EQ(ret, SOFTBUS_DATA_NOT_ENOUGH);
1418 buf->w = buf->data + DC_DATA_HEAD_SIZE;
1419 ret = TransTdcProcAllData(TRANS_TEST_CHANNEL_ID);
1420 EXPECT_EQ(ret, SOFTBUS_INVALID_DATA_HEAD);
1421
1422 pktHead->magicNumber = MAGIC_NUMBER;
1423 pktHead->dataLen = g_dataBufferMaxLen - DC_DATA_HEAD_SIZE + 1;
1424 ret = TransTdcProcAllData(TRANS_TEST_CHANNEL_ID);
1425 EXPECT_EQ(ret, SOFTBUS_TRANS_INVALID_DATA_LENGTH);
1426
1427 pktHead->dataLen = OVERHEAD_LEN;
1428 ret = TransTdcProcAllData(TRANS_TEST_CHANNEL_ID);
1429 EXPECT_EQ(ret, SOFTBUS_TRANS_INVALID_DATA_LENGTH);
1430
1431 pktHead->dataLen = 1;
1432 buf->size = DC_DATA_HEAD_SIZE;
1433 ret = TransTdcProcAllData(TRANS_TEST_CHANNEL_ID);
1434 EXPECT_EQ(ret, SOFTBUS_TRANS_INVALID_DATA_LENGTH);
1435
1436 pktHead->dataLen = OVERHEAD_LEN + 1;
1437 buf->size = DC_DATA_HEAD_SIZE;
1438 ret = TransTdcProcAllData(TRANS_TEST_CHANNEL_ID);
1439 EXPECT_EQ(ret, SOFTBUS_OK);
1440
1441 pktHead->dataLen = 0;
1442 ret = TransTdcProcAllData(TRANS_TEST_CHANNEL_ID);
1443 EXPECT_EQ(ret, SOFTBUS_DATA_NOT_ENOUGH);
1444 // pktHead is deleted in the abnormal branch
1445 SoftBusFree(buf);
1446 DestroySoftBusList(g_tcpDataList);
1447 g_tcpDataList = nullptr;
1448 }
1449
1450 /**
1451 * @tc.name: TransAssembleTlvData001
1452 * @tc.desc: TransAssembleTlvData
1453 * @tc.type: FUNC
1454 * @tc.require:
1455 */
1456 HWTEST_F(TransTcpDirectTest, TransAssembleTlvData001, TestSize.Level1)
1457 {
1458 int32_t bufferSize = 0;
1459 int32_t ret = TransAssembleTlvData(nullptr, 1, nullptr, 1, &bufferSize);
1460 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1461 }
1462
1463 /**
1464 * @tc.name: TransAssembleTlvData002
1465 * @tc.desc: TransAssembleTlvData
1466 * @tc.type: FUNC
1467 * @tc.require:
1468 */
1469 HWTEST_F(TransTcpDirectTest, TransAssembleTlvData002, TestSize.Level1)
1470 {
1471 DataHead pktHead;
1472 uint8_t *tlvElement = (uint8_t *)SoftBusCalloc(TDC_TLV_ELEMENT * sizeof(TlvElement));
1473 pktHead.tlvElement = tlvElement;
1474 pktHead.magicNum = SoftBusHtoLl(MAGIC_NUMBER);
1475 int32_t bufferSize = 0;
1476 int32_t ret = TransAssembleTlvData(&pktHead, TLV_TYPE_INNER_SEQ, nullptr, 1, &bufferSize);
1477 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1478
1479 uint8_t buffer = 0;
1480 ret = TransAssembleTlvData(&pktHead, TLV_TYPE_FLAG, &buffer, 1, &bufferSize);
1481 EXPECT_EQ(ret, SOFTBUS_OK);
1482
1483 ret = TransAssembleTlvData(&pktHead, TLV_TYPE_DATA_LEN, &buffer, 1, nullptr);
1484 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1485 SoftBusFree(tlvElement);
1486 }
1487
1488 /**
1489 * @tc.name: BuildNeedAckTlvData001
1490 * @tc.desc: BuildNeedAckTlvData
1491 * @tc.type: FUNC
1492 * @tc.require:
1493 */
1494 HWTEST_F(TransTcpDirectTest, BuildNeedAckTlvData001, TestSize.Level1)
1495 {
1496 int32_t bufferSize = 0;
1497 int32_t ret = BuildNeedAckTlvData(nullptr, true, 1, &bufferSize);
1498 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1499 }
1500
1501 /**
1502 * @tc.name: BuildDataHead001
1503 * @tc.desc: BuildDataHead
1504 * @tc.type: FUNC
1505 * @tc.require:
1506 */
1507 HWTEST_F(TransTcpDirectTest, BuildDataHead001, TestSize.Level1)
1508 {
1509 int32_t bufferSize = 0;
1510 DataHead data;
1511 int32_t ret = BuildDataHead(&data, 1, 0, 32, &bufferSize);
1512 EXPECT_EQ(ret, SOFTBUS_OK);
1513 }
1514
1515 /**
1516 * @tc.name: TransTdcNeedSendAck001
1517 * @tc.desc: TransTdcNeedSendAck
1518 * @tc.type: FUNC
1519 * @tc.require:
1520 */
1521 HWTEST_F(TransTcpDirectTest, TransTdcNeedSendAck001, TestSize.Level1)
1522 {
1523 int32_t ret = TransTdcNeedSendAck(nullptr, 1, 0, false);
1524 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1525 }
1526 }
1527