1 /*
2 * Copyright (c) 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_listener.c"
20 #include "client_trans_tcp_direct_manager.c"
21 #include "client_trans_tcp_direct_message.c"
22
23 #include "softbus_access_token_test.h"
24 #include "softbus_app_info.h"
25 #include "softbus_def.h"
26 #include "softbus_error_code.h"
27 #include "trans_tcp_direct_tlv_mock.h"
28 #include "trans_tcp_process_data.h"
29 #include "trans_tcp_process_data.c"
30
31 #define TDC_TLV_ELEMENT 5
32 #define DATA_SIZE 4
33 #define PKG_HEAD_SIZE 32
34 #define TRANS_TEST_FD 1000
35 #define TRANS_TEST_CHANNEL_ID 1
36 #define TEST_DATA_LEN 100
37
38 static int32_t g_fd = socket(AF_INET, SOCK_STREAM, 0);
39
40 using namespace testing;
41 using namespace testing::ext;
42
43 namespace OHOS {
44
45 class TransTcpDirectMockTest : public testing::Test {
46 public:
TransTcpDirectMockTest()47 TransTcpDirectMockTest()
48 {}
~TransTcpDirectMockTest()49 ~TransTcpDirectMockTest()
50 {}
51 static void SetUpTestCase(void);
52 static void TearDownTestCase(void);
SetUp()53 void SetUp() override
54 {}
TearDown()55 void TearDown() override
56 {}
57 };
58
SetUpTestCase(void)59 void TransTcpDirectMockTest::SetUpTestCase(void)
60 {
61 SetAccessTokenPermission("dsoftbusTransTest");
62 g_tcpDirectChannelInfoList = CreateSoftBusList();
63 ASSERT_NE(g_tcpDirectChannelInfoList, nullptr);
64 }
65
TearDownTestCase(void)66 void TransTcpDirectMockTest::TearDownTestCase(void)
67 {
68 DestroySoftBusList(g_tcpDirectChannelInfoList);
69 g_tcpDirectChannelInfoList = nullptr;
70 }
71
72 /**
73 * @tc.name: BuildNeedAckTlvData001
74 * @tc.desc: BuildNeedAckTlvData
75 * @tc.type: FUNC
76 * @tc.require:
77 */
78 HWTEST_F(TransTcpDirectMockTest, BuildNeedAckTlvData001, TestSize.Level1)
79 {
80 int32_t bufferSize = 0;
81 DataHead *data = reinterpret_cast<DataHead *>(SoftBusCalloc(sizeof(DataHead)));
82 ASSERT_NE(data, nullptr);
83 data->magicNum = MAGIC_NUMBER;
84 data->tlvCount = TDC_TLV_ELEMENT;
85 NiceMock<TransTcpDirectInterfaceMock> tcpDirectMock;
86 EXPECT_CALL(tcpDirectMock, TransAssembleTlvData).WillOnce(Return(SOFTBUS_MEM_ERR));
87 int32_t ret = BuildNeedAckTlvData(data, true, 1, &bufferSize);
88 EXPECT_EQ(ret, SOFTBUS_MEM_ERR);
89 SoftBusFree(data);
90 }
91
92 /**
93 * @tc.name: BuildNeedAckTlvData002
94 * @tc.desc: BuildNeedAckTlvData
95 * @tc.type: FUNC
96 * @tc.require:
97 */
98 HWTEST_F(TransTcpDirectMockTest, BuildNeedAckTlvData002, TestSize.Level1)
99 {
100 int32_t bufferSize = 0;
101 DataHead *data = reinterpret_cast<DataHead *>(SoftBusCalloc(sizeof(DataHead)));
102 ASSERT_NE(data, nullptr);
103 data->magicNum = MAGIC_NUMBER;
104 data->tlvCount = TDC_TLV_ELEMENT;
105 NiceMock<TransTcpDirectInterfaceMock> tcpDirectMock;
106 EXPECT_CALL(tcpDirectMock, TransAssembleTlvData).WillOnce(Return(SOFTBUS_OK)).WillOnce(Return(SOFTBUS_MALLOC_ERR));
107 int32_t ret = BuildNeedAckTlvData(data, true, 1, &bufferSize);
108 EXPECT_EQ(ret, SOFTBUS_MALLOC_ERR);
109 SoftBusFree(data);
110 }
111
112 /**
113 * @tc.name: BuildNeedAckTlvData003
114 * @tc.desc: BuildNeedAckTlvData
115 * @tc.type: FUNC
116 * @tc.require:
117 */
118 HWTEST_F(TransTcpDirectMockTest, BuildNeedAckTlvData003, TestSize.Level1)
119 {
120 int32_t bufferSize = 0;
121 DataHead *data = reinterpret_cast<DataHead *>(SoftBusCalloc(sizeof(DataHead)));
122 ASSERT_NE(data, nullptr);
123 data->magicNum = MAGIC_NUMBER;
124 data->tlvCount = TDC_TLV_ELEMENT;
125 NiceMock<TransTcpDirectInterfaceMock> tcpDirectMock;
126 EXPECT_CALL(tcpDirectMock, TransAssembleTlvData).WillOnce(Return(SOFTBUS_OK)).WillOnce(Return(SOFTBUS_OK));
127 int32_t ret = BuildNeedAckTlvData(data, true, 1, &bufferSize);
128 EXPECT_EQ(ret, SOFTBUS_OK);
129 SoftBusFree(data);
130 }
131
132 /**
133 * @tc.name: BuildDataHead001
134 * @tc.desc: BuildDataHead
135 * @tc.type: FUNC
136 * @tc.require:
137 */
138 HWTEST_F(TransTcpDirectMockTest, BuildDataHead001, TestSize.Level1)
139 {
140 int32_t bufferSize = 0;
141 DataHead *data = reinterpret_cast<DataHead *>(SoftBusCalloc(sizeof(DataHead)));
142 ASSERT_NE(data, nullptr);
143 data->magicNum = MAGIC_NUMBER;
144 data->tlvCount = TDC_TLV_ELEMENT;
145 NiceMock<TransTcpDirectInterfaceMock> tcpDirectMock;
146 EXPECT_CALL(tcpDirectMock, TransAssembleTlvData).WillOnce(Return(SOFTBUS_MEM_ERR));
147 int32_t ret = BuildDataHead(data, 1, 0, PKG_HEAD_SIZE, &bufferSize);
148 EXPECT_EQ(ret, SOFTBUS_MEM_ERR);
149
150 EXPECT_CALL(tcpDirectMock, TransAssembleTlvData).WillOnce(Return(SOFTBUS_OK)).WillOnce(Return(SOFTBUS_MALLOC_ERR));
151 ret = BuildDataHead(data, 1, 0, PKG_HEAD_SIZE, &bufferSize);
152 EXPECT_EQ(ret, SOFTBUS_MALLOC_ERR);
153
154 EXPECT_CALL(tcpDirectMock, TransAssembleTlvData).WillOnce(Return(SOFTBUS_OK)).WillOnce(Return(SOFTBUS_OK)).WillOnce(
155 Return(SOFTBUS_MALLOC_ERR));
156 ret = BuildDataHead(data, 1, 0, PKG_HEAD_SIZE, &bufferSize);
157 EXPECT_EQ(ret, SOFTBUS_MALLOC_ERR);
158
159 EXPECT_CALL(tcpDirectMock, TransAssembleTlvData).WillOnce(Return(SOFTBUS_OK)).WillOnce(Return(SOFTBUS_OK)).WillOnce(
160 Return(SOFTBUS_OK));
161 ret = BuildDataHead(data, 1, 0, PKG_HEAD_SIZE, &bufferSize);
162 SoftBusFree(data);
163 EXPECT_EQ(ret, SOFTBUS_OK);
164 }
165
166 /**
167 * @tc.name: TransTdcParseTlv001
168 * @tc.desc: TransTdcParseTlv and TcpDataPacketHead
169 * @tc.type: FUNC
170 * @tc.require:
171 */
172 HWTEST_F(TransTcpDirectMockTest, TransTdcParseTlv001, TestSize.Level1)
173 {
174 TcpDataPacketHead data;
175 data.magicNumber = MAGIC_NUMBER;
176 data.seq = 1;
177 data.flags = 0;
178 data.dataLen = DATA_SIZE;
179 PackTcpDataPacketHead(&data);
180 uint32_t bufferSize = 0;
181 int32_t ret = TransTdcParseTlv(TEST_DATA_LEN, nullptr, nullptr, &bufferSize);
182 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
183 }
184
185 /**
186 * @tc.name: TransTdcSetPendingPacket001
187 * @tc.desc: TransTdcSetPendingPacket
188 * @tc.type: FUNC
189 * @tc.require:
190 */
191 HWTEST_F(TransTcpDirectMockTest, TransTdcSetPendingPacket001, TestSize.Level1)
192 {
193 const char *data = "test";
194 NiceMock<TransTcpDirectInterfaceMock> tcpDirectMock;
195 EXPECT_CALL(tcpDirectMock, ClientGetSessionIdByChannelId).WillOnce(Return(SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND));
196 int32_t ret = TransTdcSetPendingPacket(1, data, DATA_SIZE, 1);
197 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
198 }
199
200 /**
201 * @tc.name: TransTdcSetPendingPacket002
202 * @tc.desc: TransTdcSetPendingPacket
203 * @tc.type: FUNC
204 * @tc.require:
205 */
206 HWTEST_F(TransTcpDirectMockTest, TransTdcSetPendingPacket002, TestSize.Level1)
207 {
208 const char *data = "test";
209 NiceMock<TransTcpDirectInterfaceMock> tcpDirectMock;
210 EXPECT_CALL(tcpDirectMock, ClientGetSessionIdByChannelId).WillOnce(Return(SOFTBUS_OK));
211 EXPECT_CALL(tcpDirectMock, ClientGetSessionCallbackAdapterById).WillOnce(Return(
212 SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND));
213 int32_t ret = TransTdcSetPendingPacket(1, data, DATA_SIZE, 1);
214 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
215 }
216
217 /**
218 * @tc.name: TransTdcSetPendingPacket003
219 * @tc.desc: TransTdcSetPendingPacket
220 * @tc.type: FUNC
221 * @tc.require:
222 */
223 HWTEST_F(TransTcpDirectMockTest, TransTdcSetPendingPacket003, TestSize.Level1)
224 {
225 const char *data = "test";
226 NiceMock<TransTcpDirectInterfaceMock> tcpDirectMock;
227 EXPECT_CALL(tcpDirectMock, ClientGetSessionIdByChannelId).WillOnce(Return(SOFTBUS_OK));
228 EXPECT_CALL(tcpDirectMock, ClientGetSessionCallbackAdapterById).WillOnce(Return(SOFTBUS_OK));
229 EXPECT_CALL(tcpDirectMock, DeleteDataSeqInfoList).WillOnce(Return(SOFTBUS_TRANS_DATA_SEQ_INFO_NOT_FOUND));
230 int32_t ret = TransTdcSetPendingPacket(1, data, DATA_SIZE, 1);
231 EXPECT_EQ(ret, SOFTBUS_TRANS_DATA_SEQ_INFO_NOT_FOUND);
232 }
233
234 /**
235 * @tc.name: TransTcpSetTos001
236 * @tc.desc: TransTcpSetTos
237 * @tc.type: FUNC
238 * @tc.require:
239 */
240 HWTEST_F(TransTcpDirectMockTest, TransTcpSetTos001, TestSize.Level1)
241 {
242 TcpDirectChannelInfo channel;
243 channel.channelId = 1;
244 int32_t ret = TransTcpSetTos(nullptr, 0);
245 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
246
247 NiceMock<TransTcpDirectInterfaceMock> tcpDirectMock;
248 EXPECT_CALL(tcpDirectMock, ClientGetSessionNameByChannelId).WillOnce(Return(SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND));
249 ret = TransTcpSetTos(&channel, 0);
250 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_NAME_NO_EXIST);
251
252 EXPECT_CALL(tcpDirectMock, ClientGetSessionNameByChannelId).WillOnce(Return(SOFTBUS_OK));
253 EXPECT_CALL(tcpDirectMock, SetIpTos).WillOnce(Return(SOFTBUS_TCP_SOCKET_ERR));
254 ret = TransTcpSetTos(&channel, 0);
255 EXPECT_EQ(ret, SOFTBUS_TCP_SOCKET_ERR);
256
257 channel.detail.fdProtocol = LNN_PROTOCOL_MINTP;
258 EXPECT_CALL(tcpDirectMock, ClientGetSessionNameByChannelId).WillOnce(Return(SOFTBUS_OK));
259 EXPECT_CALL(tcpDirectMock, SetMintpSocketTos).WillOnce(Return(-1));
260 ret = TransTcpSetTos(&channel, 0);
261 EXPECT_NE(ret, SOFTBUS_OK);
262
263 EXPECT_CALL(tcpDirectMock, ClientGetSessionNameByChannelId).WillOnce(Return(SOFTBUS_OK));
264 EXPECT_CALL(tcpDirectMock, SetMintpSocketTos).WillOnce(Return(SOFTBUS_OK));
265 ret = TransTcpSetTos(&channel, 0);
266 EXPECT_EQ(ret, SOFTBUS_OK);
267
268 channel.detail.fdProtocol = LNN_PROTOCOL_IP;
269 EXPECT_CALL(tcpDirectMock, ClientGetSessionNameByChannelId).WillOnce(Return(SOFTBUS_OK));
270 EXPECT_CALL(tcpDirectMock, SetIpTos).WillOnce(Return(SOFTBUS_OK));
271 ret = TransTcpSetTos(&channel, 0);
272 EXPECT_EQ(ret, SOFTBUS_OK);
273 }
274
275 /**
276 * @tc.name: TransSetTosSendData001
277 * @tc.desc: TransSetTosSendData
278 * @tc.type: FUNC
279 * @tc.require:
280 */
281 HWTEST_F(TransTcpDirectMockTest, TransSetTosSendData001, TestSize.Level1)
282 {
283 int32_t newPkgHeadSize = PKG_HEAD_SIZE;
284 const char *buf = "test";
285 uint32_t outLen = DATA_SIZE;
286 int32_t ret = TransSetTosSendData(nullptr, const_cast<char *>(buf), newPkgHeadSize, 0, outLen);
287 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
288 }
289
290 /**
291 * @tc.name: TransTdcSendBytes001
292 * @tc.desc: TransTdcSendBytes
293 * @tc.type: FUNC
294 * @tc.require:
295 */
296 HWTEST_F(TransTcpDirectMockTest, TransTdcSendBytes001, TestSize.Level1)
297 {
298 int32_t channelId = 1;
299 const char *data = "data";
300 uint32_t len = DATA_SIZE;
301 TcpDirectChannelInfo *info = reinterpret_cast<TcpDirectChannelInfo *>(SoftBusCalloc(sizeof(TcpDirectChannelInfo)));
302 ASSERT_NE(info, nullptr);
303
304 info->channelId = channelId;
305 info->detail.needRelease = true;
306 info->detail.sequence = 2;
307 (void)SoftBusMutexLock(&g_tcpDirectChannelInfoList->lock);
308 ListAdd(&g_tcpDirectChannelInfoList->list, &info->node);
309 (void)SoftBusMutexUnlock(&g_tcpDirectChannelInfoList->lock);
310
311 NiceMock<TransTcpDirectInterfaceMock> tcpDirectMock;
312 EXPECT_CALL(tcpDirectMock, AddPendingPacket).WillOnce(Return(SOFTBUS_TRANS_TDC_CHANNEL_ALREADY_PENDING));
313 int32_t ret = TransTdcSendBytes(channelId, data, len, true);
314 EXPECT_EQ(ret, SOFTBUS_TRANS_TDC_CHANNEL_ALREADY_PENDING);
315
316 ret = TransTdcSendBytes(channelId, data, len, true);
317 EXPECT_EQ(ret, SOFTBUS_TRANS_TDC_GET_INFO_FAILED);
318 }
319
320 /**
321 * @tc.name: TransTdcSendBytes002
322 * @tc.desc: TransTdcSendBytes
323 * @tc.type: FUNC
324 * @tc.require:
325 */
326 HWTEST_F(TransTcpDirectMockTest, TransTdcSendBytes002, TestSize.Level1)
327 {
328 int32_t channelId = 1;
329 const char *data = "data";
330 uint32_t len = DATA_SIZE;
331 TcpDirectChannelInfo *info = reinterpret_cast<TcpDirectChannelInfo *>(SoftBusCalloc(sizeof(TcpDirectChannelInfo)));
332 ASSERT_NE(info, nullptr);
333
334 info->channelId = channelId;
335 info->detail.needRelease = false;
336 info->detail.sequence = 2;
337 (void)SoftBusMutexLock(&g_tcpDirectChannelInfoList->lock);
338 ListAdd(&g_tcpDirectChannelInfoList->list, &info->node);
339 (void)SoftBusMutexUnlock(&g_tcpDirectChannelInfoList->lock);
340
341 NiceMock<TransTcpDirectInterfaceMock> tcpDirectMock;
342 EXPECT_CALL(tcpDirectMock, AddPendingPacket).WillOnce(Return(SOFTBUS_OK));
343 int32_t ret = TransTdcSendBytes(channelId, data, len, true);
344 EXPECT_EQ(ret, SOFTBUS_LOCK_ERR);
345 ListDelete(&info->node);
346 SoftBusFree(info);
347 }
348
349 /**
350 * @tc.name: TransTdcAsyncSendBytes001
351 * @tc.desc: TransTdcAsyncSendBytes
352 * @tc.type: FUNC
353 * @tc.require:
354 */
355 HWTEST_F(TransTcpDirectMockTest, TransTdcAsyncSendBytes001, TestSize.Level1)
356 {
357 int32_t ret = TransTdcAsyncSendBytes(1, nullptr, 1, 1);
358 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
359
360 const char *data = "test";
361 ret = TransTdcAsyncSendBytes(1, data, 0, 1);
362 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
363
364 ret = TransTdcAsyncSendBytes(1, nullptr, 0, 1);
365 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
366
367 TcpDirectChannelInfo *info = reinterpret_cast<TcpDirectChannelInfo *>(SoftBusCalloc(sizeof(TcpDirectChannelInfo)));
368 ASSERT_NE(info, nullptr);
369
370 info->channelId = 1;
371 info->detail.needRelease = true;
372 info->detail.sequence = 2;
373 (void)SoftBusMutexLock(&g_tcpDirectChannelInfoList->lock);
374 ListAdd(&g_tcpDirectChannelInfoList->list, &info->node);
375 (void)SoftBusMutexUnlock(&g_tcpDirectChannelInfoList->lock);
376
377 ret = TransTdcAsyncSendBytes(1, data, DATA_SIZE, 1);
378 EXPECT_EQ(ret, SOFTBUS_TRANS_TDC_CHANNEL_CLOSED_BY_ANOTHER_THREAD);
379 ListDelete(&info->node);
380 SoftBusFree(info);
381 }
382
383 /**
384 * @tc.name: TransTdcSendAck001
385 * @tc.desc: TransTdcSendAck
386 * @tc.type: FUNC
387 * @tc.require:
388 */
389 HWTEST_F(TransTcpDirectMockTest, TransTdcSendAck001, TestSize.Level1)
390 {
391 int32_t channelId = 1;
392 TcpDirectChannelInfo *info = reinterpret_cast<TcpDirectChannelInfo *>(SoftBusCalloc(sizeof(TcpDirectChannelInfo)));
393 ASSERT_NE(info, nullptr);
394
395 info->channelId = channelId;
396 info->detail.needRelease = true;
397 (void)SoftBusMutexLock(&g_tcpDirectChannelInfoList->lock);
398 ListAdd(&g_tcpDirectChannelInfoList->list, &info->node);
399 (void)SoftBusMutexUnlock(&g_tcpDirectChannelInfoList->lock);
400
401 int32_t ret = TransTdcSendAck(channelId, 1);
402 EXPECT_EQ(ret, SOFTBUS_TRANS_TDC_CHANNEL_CLOSED_BY_ANOTHER_THREAD);
403 ListDelete(&info->node);
404 SoftBusFree(info);
405 }
406
407 /**
408 * @tc.name: TransTdcNeedSendAck002
409 * @tc.desc: TransTdcNeedSendAck
410 * @tc.type: FUNC
411 * @tc.require:
412 */
413 HWTEST_F(TransTcpDirectMockTest, TransTdcNeedSendAck001, TestSize.Level1)
414 {
415 int32_t channelId = 1;
416 TcpDirectChannelInfo *info = reinterpret_cast<TcpDirectChannelInfo *>(SoftBusCalloc(sizeof(TcpDirectChannelInfo)));
417 ASSERT_NE(info, nullptr);
418
419 info->channelId = channelId;
420 info->detail.needRelease = false;
421 (void)SoftBusMutexLock(&g_tcpDirectChannelInfoList->lock);
422 ListAdd(&g_tcpDirectChannelInfoList->list, &info->node);
423 (void)SoftBusMutexUnlock(&g_tcpDirectChannelInfoList->lock);
424 int32_t ret = TransTdcNeedSendAck(info, 1, 0, false);
425 EXPECT_EQ(ret, SOFTBUS_OK);
426 ListDelete(&info->node);
427 SoftBusFree(info);
428 }
429
430 /**
431 * @tc.name: TransTdcProcessBytesDataByFlag001
432 * @tc.desc: TransTdcProcessBytesDataByFlag
433 * @tc.type: FUNC
434 * @tc.require:
435 */
436 HWTEST_F(TransTcpDirectMockTest, TransTdcProcessBytesDataByFlag001, TestSize.Level1)
437 {
438 TcpDirectChannelInfo *info = reinterpret_cast<TcpDirectChannelInfo *>(SoftBusCalloc(sizeof(TcpDirectChannelInfo)));
439 ASSERT_NE(info, nullptr);
440 info->detail.needRelease = false;
441 info->channelId = TRANS_TEST_CHANNEL_ID;
442 info->detail.channelType = CHANNEL_TYPE_TCP_DIRECT;
443 info->detail.fd = TRANS_TEST_FD;
444 (void)SoftBusMutexLock(&g_tcpDirectChannelInfoList->lock);
445 ListAdd(&g_tcpDirectChannelInfoList->list, &info->node);
446 (void)SoftBusMutexUnlock(&g_tcpDirectChannelInfoList->lock);
447 TcpDataTlvPacketHead *head = reinterpret_cast<TcpDataTlvPacketHead *>(SoftBusCalloc(sizeof(TcpDataTlvPacketHead)));
448 ASSERT_NE(head, nullptr);
449 head->flags = FLAG_BYTES;
450 const char *plain = "plain";
451 head->seq = 1;
452 head->dataSeq = 0;
453 head->needAck = false;
454 head->flags = FLAG_ACK;
455 int32_t ret = TransTdcProcessBytesDataByFlag(head, info, const_cast<char *>(plain), (uint32_t)strlen(plain));
456 EXPECT_EQ(ret, SOFTBUS_OK);
457
458 head->flags = FILE_FIRST_FRAME;
459 ret = TransTdcProcessBytesDataByFlag(head, info, const_cast<char *>(plain), (uint32_t)strlen(plain));
460 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
461 ListDelete(&info->node);
462 SoftBusFree(info);
463 SoftBusFree(head);
464 }
465
466 /**
467 * @tc.name: TransTdcProcessTlvData001
468 * @tc.desc: TransTdcProcessTlvData
469 * @tc.type: FUNC
470 * @tc.require:
471 */
472 HWTEST_F(TransTcpDirectMockTest, TransTdcProcessTlvData001, TestSize.Level1)
473 {
474 TransDataListInit();
475 TcpDirectChannelInfo channel;
476 channel.channelId = 1;
477 TcpDataTlvPacketHead *head = reinterpret_cast<TcpDataTlvPacketHead *>(SoftBusCalloc(sizeof(TcpDataTlvPacketHead)));
478 ASSERT_NE(head, nullptr);
479 head->flags = FLAG_BYTES;
480 int32_t ret = TransTdcProcessTlvData(channel.channelId, head, PKG_HEAD_SIZE);
481 EXPECT_EQ(ret, SOFTBUS_TRANS_TDC_CHANNEL_NOT_FOUND);
482 SoftBusFree(head);
483 TransDataListDeinit();
484 }
485
486 /**
487 * @tc.name: MoveNode001
488 * @tc.desc: MoveNode
489 * @tc.type: FUNC
490 * @tc.require:
491 */
492 HWTEST_F(TransTcpDirectMockTest, MoveNode001, TestSize.Level1)
493 {
494 int32_t ret = MoveNode(TRANS_TEST_CHANNEL_ID, nullptr, TEST_DATA_LEN, PKG_HEAD_SIZE);
495 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
496 }
497 } // namespace OHOS