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