1 /*
2 * Copyright (c) 2022-2023 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_message.h"
20 #include "client_trans_tcp_direct_manager.c"
21 #include "client_trans_file_listener.h"
22 #include "client_trans_tcp_direct_callback.h"
23 #include "client_trans_session_callback.h"
24 #include "client_trans_session_manager.h"
25 #include "client_trans_socket_manager.h"
26 #include "client_trans_tcp_direct_listener.h"
27 #include "session.h"
28 #include "softbus_def.h"
29 #include "softbus_error_code.h"
30 #include "softbus_adapter_mem.h"
31 #include "softbus_feature_config.h"
32 #include "softbus_access_token_test.h"
33 #include "softbus_base_listener.h"
34 #include "trans_log.h"
35 #include "trans_server_proxy.h"
36
37 using namespace testing::ext;
38
39 namespace OHOS {
40 #define INVALID_VALUE (-1)
41 #define SESSIONKEY_LEN 46
42 #define SESSION_KEY_LEN 46
43 static const char *g_sessionName = "ohos.distributedschedule.dms.test";
44 char g_peerSessionName[SESSIONKEY_LEN] = "ohos.distributedschedule.dms.test";
45 static const char *g_sessionkey = "clientkey";
46 char g_peerSessionKey[SESSION_KEY_LEN] = "clientkey";
47 static const char *g_pkgName = "pkgname";
48 static int32_t g_fd = socket(AF_INET, SOCK_STREAM, 0);
49
50 class TransSdkTcpDirectTest : public testing::Test {
51 public:
TransSdkTcpDirectTest()52 TransSdkTcpDirectTest()
53 {}
~TransSdkTcpDirectTest()54 ~TransSdkTcpDirectTest()
55 {}
56 static void SetUpTestCase(void);
57 static void TearDownTestCase(void);
SetUp()58 void SetUp() override
59 {}
TearDown()60 void TearDown() override
61 {}
62 };
63
OnServerSessionOpened(int32_t sessionId,int32_t result)64 static int32_t OnServerSessionOpened(int32_t sessionId, int32_t result)
65 {
66 TRANS_LOGI(TRANS_TEST, "session opened, sesisonId=%{public}d\r\n", sessionId);
67 return SOFTBUS_OK;
68 }
69
OnServerSessionClosed(int32_t sessionId)70 static void OnServerSessionClosed(int32_t sessionId)
71 {
72 TRANS_LOGI(TRANS_TEST, "session closed, sessionId=%{public}d\r\n", sessionId);
73 }
74
OnServerBytesReceived(int32_t sessionId,const void * data,unsigned int len)75 static void OnServerBytesReceived(int32_t sessionId, const void *data, unsigned int len)
76 {
77 TRANS_LOGI(TRANS_TEST, "session bytes received, sessionId=%{public}d\r\n", sessionId);
78 }
79
OnServerMessageReceived(int32_t sessionId,const void * data,unsigned int len)80 static void OnServerMessageReceived(int32_t sessionId, const void *data, unsigned int len)
81 {
82 TRANS_LOGI(TRANS_TEST, "session msg received, sessionId=%{public}d\r\n", sessionId);
83 }
84
85 static ISessionListener g_sessionlistener = {
86 .OnSessionOpened = OnServerSessionOpened,
87 .OnSessionClosed = OnServerSessionClosed,
88 .OnBytesReceived = OnServerBytesReceived,
89 .OnMessageReceived = OnServerMessageReceived,
90 };
91
OnSessionOpened(const char * sessionName,const ChannelInfo * channel,SessionType flag,SocketAccessInfo * accessInfo)92 static int32_t OnSessionOpened(
93 const char *sessionName, const ChannelInfo *channel, SessionType flag, SocketAccessInfo *accessInfo)
94 {
95 TRANS_LOGI(TRANS_TEST, "session opened, sesisonName=%{public}s", sessionName);
96 return SOFTBUS_OK;
97 }
98
OnSessionClosed(int32_t channelId,int32_t channelType,ShutdownReason reason)99 static int32_t OnSessionClosed(int32_t channelId, int32_t channelType, ShutdownReason reason)
100 {
101 TRANS_LOGI(TRANS_TEST, "session closed, channelId=%{public}d", channelId);
102 return SOFTBUS_OK;
103 }
104
OnSessionOpenFailed(int32_t channelId,int32_t channelType,int32_t errCode)105 static int32_t OnSessionOpenFailed(int32_t channelId, int32_t channelType, int32_t errCode)
106 {
107 TRANS_LOGI(TRANS_TEST, "session bytes received, channelId=%{public}d", channelId);
108 return SOFTBUS_OK;
109 }
110
OnDataReceived(int32_t channelId,int32_t channelType,const void * data,uint32_t len,SessionPktType type)111 static int32_t OnDataReceived(int32_t channelId, int32_t channelType,
112 const void *data, uint32_t len, SessionPktType type)
113 {
114 TRANS_LOGI(TRANS_TEST, "session msg received, channelId=%{public}d", channelId);
115 return SOFTBUS_OK;
116 }
117 static IClientSessionCallBack g_sessionCb = {
118 .OnSessionOpened = OnSessionOpened,
119 .OnSessionClosed = OnSessionClosed,
120 .OnSessionOpenFailed = OnSessionOpenFailed,
121 .OnDataReceived = OnDataReceived,
122 };
123
TestGetChannelInfo()124 ChannelInfo *TestGetChannelInfo()
125 {
126 ChannelInfo *info = (ChannelInfo *)SoftBusMalloc(sizeof(ChannelInfo));
127 (void)memset_s(info, sizeof(ChannelInfo), 0, sizeof(ChannelInfo));
128 info->peerSessionName = g_peerSessionName;
129 info->channelId = 1;
130 info->channelType = CHANNEL_TYPE_TCP_DIRECT;
131 info->sessionKey = g_peerSessionKey;
132 info->fd = g_fd;
133 return info;
134 }
135
TestGetTcpDirectChannelInfo()136 TcpDirectChannelInfo *TestGetTcpDirectChannelInfo()
137 {
138 TcpDirectChannelInfo *item = (TcpDirectChannelInfo *)SoftBusMalloc(sizeof(TcpDirectChannelInfo));
139 (void)memset_s(item, sizeof(TcpDirectChannelInfo), 0, sizeof(TcpDirectChannelInfo));
140 item->channelId = 1;
141 (void)memcpy_s(item->detail.sessionKey, SESSIONKEY_LEN, g_sessionkey, strlen(g_sessionkey));
142 item->detail.channelType = CHANNEL_TYPE_TCP_DIRECT;
143 item->detail.fd = g_fd;
144 return item;
145 }
146
SetUpTestCase(void)147 void TransSdkTcpDirectTest::SetUpTestCase(void)
148 {
149 int32_t ret = TransClientInit();
150 EXPECT_EQ(ret, SOFTBUS_OK);
151 TransTdcManagerInit(&g_sessionCb);
152 uint64_t timestamp = 0;
153 ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener, ×tamp);
154 EXPECT_EQ(ret, SOFTBUS_OK);
155 ret = InitBaseListener();
156 EXPECT_EQ(ret, SOFTBUS_OK);
157 }
158
TearDownTestCase(void)159 void TransSdkTcpDirectTest::TearDownTestCase(void)
160 {
161 TransTdcManagerDeinit();
162 }
163
164 /**
165 * @tc.name: ClientTransTdcOnChannelOpenedTest001
166 * @tc.desc: ClientTransTdcOnChannelOpened, use the wrong parameter.
167 * @tc.type: FUNC
168 * @tc.require:I5HQGA
169 */
170 HWTEST_F(TransSdkTcpDirectTest, ClientTransTdcOnChannelOpenedTest001, TestSize.Level1)
171 {
172 ChannelInfo *channel = TestGetChannelInfo();
173 ASSERT_TRUE(channel != nullptr);
174 int32_t ret = ClientTransTdcOnChannelOpened(nullptr, channel, nullptr);
175 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
176
177 ret = ClientTransTdcOnChannelOpened(g_sessionName, nullptr, nullptr);
178 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
179
180 ret = ClientTransTdcOnChannelOpened(g_sessionName, channel, nullptr);
181 EXPECT_EQ(ret, SOFTBUS_MEM_ERR);
182
183 SoftBusFree(channel);
184 }
185
186 /**
187 * @tc.name: TransTdcCloseChannelTest002
188 * @tc.desc: TransTdcCloseChannel, use the wrong parameter.
189 * @tc.type: FUNC
190 * @tc.require:I5HQGA
191 */
192 HWTEST_F(TransSdkTcpDirectTest, TransTdcCloseChannelTest002, TestSize.Level1)
193 {
194 int32_t channelId = 1;
195 ChannelInfo *channel = TestGetChannelInfo();
196 ASSERT_TRUE(channel != nullptr);
197
198 TransTdcManagerInit(&g_sessionCb);
199
200 TransTdcCloseChannel(channelId);
201
202 int32_t ret = ClientTransTdcOnChannelOpened(g_sessionName, channel, nullptr);
203 EXPECT_EQ(ret, SOFTBUS_MEM_ERR);
204
205 TransTdcCloseChannel(channelId);
206
207 channelId = INVALID_VALUE;
208 TransTdcCloseChannel(channelId);
209
210 SoftBusFree(channel);
211 }
212
213 /**
214 * @tc.name: TransTdcGetSessionKeyTest003
215 * @tc.desc: TransTdcGetSessionKey, use the wrong parameter.
216 * @tc.type: FUNC
217 * @tc.require:I5HQGA
218 */
219 HWTEST_F(TransSdkTcpDirectTest, TransTdcGetSessionKeyTest003, TestSize.Level1)
220 {
221 int32_t channelId = 1;
222 unsigned int len = 32;
223 ChannelInfo *channel = TestGetChannelInfo();
224 ASSERT_TRUE(channel != nullptr);
225
226 int32_t ret = ClientTransTdcOnChannelOpened(g_sessionName, channel, nullptr);
227 EXPECT_EQ(ret, SOFTBUS_MEM_ERR);
228
229 ret = TransTdcGetSessionKey(channelId, nullptr, len);
230 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
231
232 ret = TransTdcGetSessionKey(channelId, const_cast<char *>(g_sessionkey), len);
233 EXPECT_EQ(ret, SOFTBUS_TRANS_TDC_CHANNEL_NOT_FOUND);
234
235 channelId = INVALID_VALUE;
236 ret = TransTdcGetSessionKey(channelId, const_cast<char *>(g_sessionkey), len);
237 EXPECT_EQ(ret, SOFTBUS_TRANS_TDC_CHANNEL_NOT_FOUND);
238
239 SoftBusFree(channel);
240 }
241
242 /**
243 * @tc.name: TransTdcGetHandleTest004
244 * @tc.desc: TransTdcGetHandle, use the wrong parameter.
245 * @tc.type: FUNC
246 * @tc.require:I5HQGA
247 */
248 HWTEST_F(TransSdkTcpDirectTest, TransTdcGetHandleTest004, TestSize.Level1)
249 {
250 int32_t channelId = 1;
251 int32_t handle = 0;
252 ChannelInfo *channel = TestGetChannelInfo();
253 ASSERT_TRUE(channel != nullptr);
254
255 int32_t ret = ClientTransTdcOnChannelOpened(g_sessionName, channel, nullptr);
256 EXPECT_EQ(ret, SOFTBUS_MEM_ERR);
257
258 ret = TransTdcGetHandle(channelId, nullptr);
259 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
260
261 ret = TransTdcGetHandle(channelId, &handle);
262 EXPECT_EQ(ret, SOFTBUS_TRANS_TDC_CHANNEL_NOT_FOUND);
263
264 channelId = INVALID_VALUE;
265 ret = TransTdcGetHandle(channelId, &handle);
266 EXPECT_EQ(ret, SOFTBUS_TRANS_TDC_CHANNEL_NOT_FOUND);
267
268 SoftBusFree(channel);
269 }
270
271 /**
272 * @tc.name: TransDisableSessionListenerTest005
273 * @tc.desc: TransDisableSessionListener, use the wrong parameter.
274 * @tc.type: FUNC
275 * @tc.require:I5HQGA
276 */
277
278 HWTEST_F(TransSdkTcpDirectTest, TransDisableSessionListenerTest005, TestSize.Level1)
279 {
280 int32_t channelId = 1;
281
282 ChannelInfo *info = (ChannelInfo *)SoftBusCalloc(sizeof(ChannelInfo));
283 ASSERT_TRUE(info != nullptr);
284 (void)memset_s(info, sizeof(ChannelInfo), 0, sizeof(ChannelInfo));
285 info->peerSessionName = const_cast<char *>(g_sessionName);
286 info->channelId = 1;
287 info->channelType = CHANNEL_TYPE_TCP_DIRECT;
288 info->sessionKey = const_cast<char *>(g_sessionkey);
289 info->fd = INVALID_VALUE;
290
291 int32_t ret = ClientTransTdcOnChannelOpened(g_sessionName, info, nullptr);
292 EXPECT_EQ(ret, SOFTBUS_MEM_ERR);
293
294 info->fd = g_fd;
295 ret = TransDisableSessionListener(channelId);
296 EXPECT_EQ(ret, SOFTBUS_TRANS_TDC_CHANNEL_NOT_FOUND);
297
298 ret = TransDisableSessionListener(channelId);
299 EXPECT_EQ(ret, SOFTBUS_TRANS_TDC_CHANNEL_NOT_FOUND);
300
301 channelId = INVALID_VALUE;
302 ret = TransDisableSessionListener(channelId);
303 EXPECT_EQ(ret, SOFTBUS_TRANS_TDC_CHANNEL_NOT_FOUND);
304
305 SoftBusFree(info);
306 }
307
308 /**
309 * @tc.name: TransTdcGetInfoByIdTest006
310 * @tc.desc: TransTdcGetInfoById, use the wrong parameter.
311 * @tc.type: FUNC
312 * @tc.require:I5HQGA
313 */
314 HWTEST_F(TransSdkTcpDirectTest, TransTdcGetInfoByIdTest006, TestSize.Level1)
315 {
316 int32_t channelId = 1;
317 TcpDirectChannelInfo *info = (TcpDirectChannelInfo *)SoftBusMalloc(sizeof(TcpDirectChannelInfo));
318 ASSERT_TRUE(info != nullptr);
319 (void)memset_s(info, sizeof(TcpDirectChannelInfo), 0, sizeof(TcpDirectChannelInfo));
320
321 ChannelInfo *channel = TestGetChannelInfo();
322 ASSERT_TRUE(channel != nullptr);
323 int32_t ret = ClientTransTdcOnChannelOpened(g_sessionName, channel, nullptr);
324 EXPECT_EQ(ret, SOFTBUS_MEM_ERR);
325
326 int32_t item = TransTdcGetInfoById(channelId, nullptr);
327 EXPECT_NE(item, SOFTBUS_OK);
328
329 item = TransTdcGetInfoById(channelId, info);
330 EXPECT_NE(item, SOFTBUS_OK);
331
332 channelId = INVALID_VALUE;
333 item = TransTdcGetInfoById(channelId, info);
334 EXPECT_NE(item, SOFTBUS_OK);
335
336 SoftBusFree(info);
337 SoftBusFree(channel);
338 }
339
340 /**
341 * @tc.name: TransTdcGetInfoByFdTest007
342 * @tc.desc: TransTdcGetInfoByFd, use the wrong parameter.
343 * @tc.type: FUNC
344 * @tc.require:I5HQGA
345 */
346 HWTEST_F(TransSdkTcpDirectTest, TransTdcGetInfoByFdTest007, TestSize.Level1)
347 {
348 int32_t fd = g_fd;
349 TcpDirectChannelInfo *info = (TcpDirectChannelInfo *)SoftBusMalloc(sizeof(TcpDirectChannelInfo));
350 ASSERT_TRUE(info != nullptr);
351 (void)memset_s(info, sizeof(TcpDirectChannelInfo), 0, sizeof(TcpDirectChannelInfo));
352
353 ChannelInfo *channel = TestGetChannelInfo();
354 ASSERT_TRUE(channel != nullptr);
355 int32_t ret = ClientTransTdcOnChannelOpened(g_sessionName, channel, nullptr);
356 EXPECT_EQ(ret, SOFTBUS_MEM_ERR);
357
358 int32_t item = TransTdcGetInfoByFd(fd, nullptr);
359 EXPECT_NE(item, SOFTBUS_OK);
360
361 item = TransTdcGetInfoByFd(fd, info);
362 EXPECT_NE(item, SOFTBUS_OK);
363
364 fd = 1;
365 item = TransTdcGetInfoByFd(fd, info);
366 EXPECT_NE(item, SOFTBUS_OK);
367
368 SoftBusFree(info);
369 SoftBusFree(channel);
370 }
371
372 /**
373 * @tc.name: TransTdcGetInfoByIdWithIncSeqTest008
374 * @tc.desc: TransTdcGetInfoIncFdRefById, use the wrong parameter.
375 * @tc.type: FUNC
376 * @tc.require:I5HQGA
377 */
378 HWTEST_F(TransSdkTcpDirectTest, TransTdcGetInfoByIdWithIncSeqTest008, TestSize.Level1)
379 {
380 int32_t channelId = 1;
381 TcpDirectChannelInfo *info = (TcpDirectChannelInfo *)SoftBusMalloc(sizeof(TcpDirectChannelInfo));
382 ASSERT_TRUE(info != nullptr);
383 (void)memset_s(info, sizeof(TcpDirectChannelInfo), 0, sizeof(TcpDirectChannelInfo));
384
385 ChannelInfo *channel = TestGetChannelInfo();
386 ASSERT_TRUE(channel != nullptr);
387 int32_t ret = ClientTransTdcOnChannelOpened(g_sessionName, channel, nullptr);
388 EXPECT_EQ(ret, SOFTBUS_MEM_ERR);
389
390 TcpDirectChannelInfo *item = TransTdcGetInfoIncFdRefById(channelId, nullptr, true);
391 EXPECT_TRUE(item == nullptr);
392
393 item = TransTdcGetInfoIncFdRefById(channelId, info, true);
394 EXPECT_TRUE(item == nullptr);
395
396 channelId = INVALID_VALUE;
397 item = TransTdcGetInfoIncFdRefById(channelId, info, true);
398 EXPECT_TRUE(item == nullptr);
399
400 SoftBusFree(info);
401 SoftBusFree(channel);
402 }
403
404 /**
405 * @tc.name: ClientTransTdcSetCallBackTest009
406 * @tc.desc: ClientTransTdcSetCallBack, use the wrong parameter.
407 * @tc.type: FUNC
408 * @tc.require:I5HQGA
409 */
410 HWTEST_F(TransSdkTcpDirectTest, ClientTransTdcSetCallBackTest009, TestSize.Level1)
411 {
412 const IClientSessionCallBack *cb = GetClientSessionCb();
413 int32_t ret = ClientTransTdcSetCallBack(nullptr);
414 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
415 ret = ClientTransTdcSetCallBack(cb);
416 EXPECT_EQ(ret, SOFTBUS_OK);
417 }
418
419 /**
420 * @tc.name: ClientTransTdcOnSessionOpenedTest0010
421 * @tc.desc: ClientTransTdcOnSessionOpened, use the wrong parameter.
422 * @tc.type: FUNC
423 * @tc.require:I5HQGA
424 */
425 HWTEST_F(TransSdkTcpDirectTest, ClientTransTdcOnSessionOpenedTest0010, TestSize.Level1)
426 {
427 ChannelInfo *info = (ChannelInfo *)SoftBusCalloc(sizeof(ChannelInfo));
428 ASSERT_TRUE(info != nullptr);
429 (void)memset_s(info, sizeof(ChannelInfo), 0, sizeof(ChannelInfo));
430
431 int32_t ret = ClientTransTdcSetCallBack(&g_sessionCb);
432 ret = ClientTransTdcOnSessionOpened(g_sessionName, nullptr, nullptr);
433 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
434
435 info->isServer = true;
436 info->channelType = CHANNEL_TYPE_AUTH;
437 ret = ClientTransTdcOnSessionOpened(nullptr, info, nullptr);
438 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
439
440 ret = ClientTransTdcOnSessionOpened(g_sessionName, info, nullptr);
441 EXPECT_EQ(ret, SOFTBUS_OK);
442
443 info->isServer = false;
444 info->channelType = CHANNEL_TYPE_UDP;
445 ret = ClientTransTdcOnSessionOpened(g_sessionName, info, nullptr);
446 EXPECT_EQ(ret, SOFTBUS_OK);
447 SoftBusFree(info);
448 }
449
450 /**
451 * @tc.name: ClientTransTdcOnSessionClosedTest0011
452 * @tc.desc: ClientTransTdcOnSessionClosed, use the wrong parameter.
453 * @tc.type: FUNC
454 * @tc.require:I5HQGA
455 */
456 HWTEST_F(TransSdkTcpDirectTest, ClientTransTdcOnSessionClosedTest0011, TestSize.Level1)
457 {
458 int32_t channelId = 1;
459 int32_t errCode = SOFTBUS_OK;
460 int32_t ret = ClientTransTdcSetCallBack(&g_sessionCb);
461 ret = ClientTransTdcOnSessionClosed(channelId, SHUTDOWN_REASON_UNKNOWN);
462 EXPECT_EQ(ret, SOFTBUS_OK);
463
464 ret = ClientTransTdcOnSessionOpenFailed(channelId, errCode);
465 EXPECT_EQ(ret, SOFTBUS_OK);
466
467 const char *data = "client";
468 uint32_t len = strlen(data);
469 ret = ClientTransTdcOnDataReceived(channelId, (void *)data, len, TRANS_SESSION_FILE_ONLYONE_FRAME);
470 EXPECT_EQ(ret, SOFTBUS_OK);
471 }
472
473 /**
474 * @tc.name: TransTdcCreateListenerTest0012
475 * @tc.desc: TransTdcCreateListener, use the wrong parameter.
476 * @tc.type: FUNC
477 * @tc.require:I5HQGA
478 */
479 HWTEST_F(TransSdkTcpDirectTest, TransTdcCreateListenerTest0012, TestSize.Level1)
480 {
481 int32_t fd = INVALID_VALUE;
482 int32_t ret = TransTdcCreateListener(fd);
483 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
484 fd = g_fd;
485 ret = TransTdcCreateListener(fd);
486 EXPECT_EQ(ret, SOFTBUS_OK);
487 }
488
489 /**
490 * @tc.name: TransTdcReleaseFdTest0013
491 * @tc.desc: TransTdcReleaseFd, use the wrong parameter.
492 * @tc.type: FUNC
493 * @tc.require:I5HQGA
494 */
495 HWTEST_F(TransSdkTcpDirectTest, TransTdcReleaseFdTest0013, TestSize.Level1)
496 {
497 int32_t fd = INVALID_VALUE;
498 TransTdcReleaseFd(fd);
499 EXPECT_EQ(fd, INVALID_VALUE);
500 fd = g_fd;
501 TransTdcReleaseFd(fd);
502 EXPECT_TRUE(g_fd == fd);
503 }
504
505 /**
506 * @tc.name: TransTdcStopReadTest0014
507 * @tc.desc: TransTdcStopRead, use the wrong parameter.
508 * @tc.type: FUNC
509 * @tc.require:I5HQGA
510 */
511 HWTEST_F(TransSdkTcpDirectTest, TransTdcStopReadTest0014, TestSize.Level1)
512 {
513 int32_t fd = INVALID_VALUE;
514 int32_t ret = TransTdcStopRead(fd);
515 EXPECT_EQ(ret, SOFTBUS_OK);
516 fd = g_fd + 1;
517 ret = TransTdcCreateListener(fd);
518 EXPECT_EQ(ret, SOFTBUS_OK);
519 ret = TransTdcStopRead(fd);
520 EXPECT_EQ(ret, SOFTBUS_OK);
521 ret = TransTdcStopRead(fd);
522 EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
523 }
524
525 /**
526 * @tc.name: ClientTransTdcOnChannelOpenFailedTest0015
527 * @tc.desc: ClientTransTdcOnChannelOpenFailed, use the wrong parameter.
528 * @tc.type: FUNC
529 * @tc.require:I5HQGA
530 */
531 HWTEST_F(TransSdkTcpDirectTest, ClientTransTdcOnChannelOpenFailedTest0015, TestSize.Level1)
532 {
533 int32_t channelId = 1;
534 int32_t errCode = SOFTBUS_OK;
535 int32_t ret = ClientTransTdcOnChannelOpenFailed(channelId, errCode);
536 EXPECT_EQ(ret, SOFTBUS_OK);
537
538 channelId = INVALID_VALUE;
539 ret = ClientTransTdcOnChannelOpenFailed(channelId, errCode);
540 EXPECT_EQ(ret, SOFTBUS_OK);
541 }
542
543 /**
544 * @tc.name: TransDataListInitTest0016
545 * @tc.desc: TransDataListInit, use the wrong parameter.
546 * @tc.type: FUNC
547 * @tc.require:I5HQGA
548 */
549 HWTEST_F(TransSdkTcpDirectTest, TransDataListInitTest0016, TestSize.Level1)
550 {
551 int32_t channelId = 1;
552 int32_t fd = 1;
553 TransDataListDeinit();
554 int32_t ret = TransAddDataBufNode(channelId, fd);
555 EXPECT_EQ(ret, SOFTBUS_NO_INIT);
556
557 ret = TransDelDataBufNode(channelId);
558 EXPECT_EQ(ret, SOFTBUS_NO_INIT);
559
560 ret = TransDataListInit();
561 ASSERT_EQ(ret, SOFTBUS_OK);
562
563 ret = TransAddDataBufNode(channelId, fd);
564 ASSERT_EQ(ret, SOFTBUS_OK);
565
566 ret = TransDelDataBufNode(channelId);
567 EXPECT_EQ(ret, SOFTBUS_OK);
568
569 TransDataListDeinit();
570 }
571
572 /**
573 * @tc.name: TransTdcSendBytesTest0017
574 * @tc.desc: TransTdcSendBytes, use the wrong parameter.
575 * @tc.type: FUNC
576 * @tc.require:I5HQGA
577 */
578 HWTEST_F(TransSdkTcpDirectTest, TransTdcSendBytesTest0017, TestSize.Level1)
579 {
580 int32_t channelId = 1;
581 const char *data = "data";
582 uint32_t len = (uint32_t)strlen(data);
583 int32_t ret = TransTdcSendBytes(channelId, nullptr, len, false);
584 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
585
586 ret = TransTdcSendBytes(channelId, data, 0, false);
587 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
588
589 ret = TransTdcSendBytes(channelId, data, len, false);
590 EXPECT_EQ(ret, SOFTBUS_TRANS_TDC_GET_INFO_FAILED);
591
592 ChannelInfo *channel = TestGetChannelInfo();
593 ASSERT_TRUE(channel != nullptr);
594 ret = ClientTransTdcOnChannelOpened(g_sessionName, channel, nullptr);
595 EXPECT_EQ(ret, SOFTBUS_MEM_ERR);
596
597 ret = TransTdcSendBytes(channelId, data, len, false);
598 EXPECT_EQ(ret, SOFTBUS_TRANS_TDC_GET_INFO_FAILED);
599
600 SoftBusFree(channel);
601 }
602
603 /**
604 * @tc.name: TransTdcSendMessageTest0018
605 * @tc.desc: TransTdcSendMessage, use the wrong parameter.
606 * @tc.type: FUNC
607 * @tc.require:I5HQGA
608 */
609 HWTEST_F(TransSdkTcpDirectTest, TransTdcSendMessageTest0018, TestSize.Level1)
610 {
611 int32_t channelId = 1;
612 const char *data = "data";
613 uint32_t len = (uint32_t)strlen(data);
614 int32_t ret = TransTdcSendMessage(channelId, nullptr, len);
615 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
616
617 ret = TransTdcSendMessage(channelId, data, 0);
618 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
619
620 ret = TransTdcSendMessage(channelId, data, len);
621 EXPECT_EQ(ret, SOFTBUS_TRANS_TDC_CHANNEL_NOT_FOUND);
622
623 ChannelInfo *channel = TestGetChannelInfo();
624 ASSERT_TRUE(channel != nullptr);
625 ret = ClientTransTdcOnChannelOpened(g_sessionName, channel, nullptr);
626 EXPECT_EQ(ret, SOFTBUS_MEM_ERR);
627
628 ret = TransTdcSendMessage(channelId, data, len);
629 EXPECT_EQ(ret, SOFTBUS_TRANS_TDC_CHANNEL_NOT_FOUND);
630
631 SoftBusFree(channel);
632 }
633
634 /**
635 * @tc.name: TransTdcRecvDataTest0019
636 * @tc.desc: TransTdcRecvData, use the wrong parameter.
637 * @tc.type: FUNC
638 * @tc.require:I5HQGA
639 */
640 HWTEST_F(TransSdkTcpDirectTest, TransTdcRecvDataTest0019, TestSize.Level1)
641 {
642 int32_t channelId = 1;
643 int32_t fd = 1;
644 int32_t ret = TransTdcRecvData(channelId);
645 EXPECT_EQ(ret, SOFTBUS_NO_INIT);
646
647 ret = TransDataListInit();
648 ASSERT_EQ(ret, SOFTBUS_OK);
649
650 ret = TransTdcRecvData(channelId);
651 EXPECT_EQ(ret, SOFTBUS_TRANS_TDC_CHANNEL_NOT_FOUND);
652
653 ret = TransAddDataBufNode(channelId, fd);
654 ASSERT_EQ(ret, SOFTBUS_OK);
655
656 ret = TransTdcRecvData(channelId);
657 EXPECT_EQ(ret, SOFTBUS_TRANS_INVALID_DATA_LENGTH);
658 TransDataListDeinit();
659 }
660
661 /**
662 * @tc.name: TransTdcCreateListenerWithoutAddTriggerTest002
663 * @tc.desc: TransTdcCreateListenerWithoutAddTrigger, use the wrong paramter
664 * @tc.type: FUNC
665 * @tc.require:I5HQGA
666 */
667 HWTEST_F(TransSdkTcpDirectTest, TransTdcCreateListenerWithoutAddTriggerTest0020, TestSize.Level1)
668 {
669 int32_t fd = g_fd;
670 int32_t ret = TransTdcCreateListenerWithoutAddTrigger(fd);
671 EXPECT_EQ(ret, SOFTBUS_OK);
672 }
673
674 /**
675 * @tc.name: ClientTransCheckTdcChannelExist001
676 * @tc.desc: ClientTransCheckTdcChannelExist, use the wrong parameter.
677 * @tc.type: FUNC
678 * @tc.require:I5HQGA
679 */
680 HWTEST_F(TransSdkTcpDirectTest, ClientTransCheckTdcChannelExist001, TestSize.Level1)
681 {
682 int32_t channelId = 1;
683 int32_t ret = ClientTransCheckTdcChannelExist(1);
684 EXPECT_EQ(ret, SOFTBUS_OK);
685
686 TcpDirectChannelInfo *info = (TcpDirectChannelInfo *)SoftBusCalloc(sizeof(TcpDirectChannelInfo));
687 ASSERT_TRUE(info != nullptr);
688
689 g_tcpDirectChannelInfoList = CreateSoftBusList();
690 ASSERT_TRUE(g_tcpDirectChannelInfoList != nullptr);
691
692 info->channelId = channelId;
693 (void)SoftBusMutexLock(&g_tcpDirectChannelInfoList->lock);
694 ListAdd(&g_tcpDirectChannelInfoList->list, &info->node);
695 (void)SoftBusMutexUnlock(&g_tcpDirectChannelInfoList->lock);
696
697 ret = ClientTransCheckTdcChannelExist(channelId);
698 EXPECT_EQ(ret, SOFTBUS_TRANS_TDC_CHANNEL_ALREADY_EXIST);
699
700 SoftBusFree(info);
701 DestroySoftBusList(g_tcpDirectChannelInfoList);
702 g_tcpDirectChannelInfoList = nullptr;
703 }
704
705 /**
706 * @tc.name: TransTdcDelChannelInfo001
707 * @tc.desc: TransTdcDelChannelInfo, use the wrong parameter.
708 * @tc.type: FUNC
709 * @tc.require:I5HQGA
710 */
711 HWTEST_F(TransSdkTcpDirectTest, TransTdcDelChannelInfo001, TestSize.Level1)
712 {
713 int32_t channelId1 = 1;
714 int32_t channelId2 = 2;
715 TransTdcDelChannelInfo(1, SOFTBUS_TRANS_NEGOTIATE_REJECTED);
716 EXPECT_TRUE(g_tcpDirectChannelInfoList == nullptr);
717
718 TcpDirectChannelInfo *info = (TcpDirectChannelInfo *)SoftBusCalloc(sizeof(TcpDirectChannelInfo));
719 ASSERT_TRUE(info != nullptr);
720
721 g_tcpDirectChannelInfoList = CreateSoftBusList();
722 ASSERT_TRUE(g_tcpDirectChannelInfoList != nullptr);
723
724 info->channelId = channelId1;
725 (void)SoftBusMutexLock(&g_tcpDirectChannelInfoList->lock);
726 ListAdd(&g_tcpDirectChannelInfoList->list, &info->node);
727 (void)SoftBusMutexUnlock(&g_tcpDirectChannelInfoList->lock);
728
729 TransTdcDelChannelInfo(channelId2, SOFTBUS_TRANS_NEGOTIATE_REJECTED);
730 TransTdcDelChannelInfo(channelId1, SOFTBUS_TRANS_NEGOTIATE_REJECTED);
731 // info is deleted in the abnormal branch
732 DestroySoftBusList(g_tcpDirectChannelInfoList);
733 g_tcpDirectChannelInfoList = nullptr;
734 }
735
736 /**
737 * @tc.name: TransTdcDelChannelInfo002
738 * @tc.desc: TransTdcDelChannelInfo, use the wrong parameter.
739 * @tc.type: FUNC
740 * @tc.require:I5HQGA
741 */
742 HWTEST_F(TransSdkTcpDirectTest, TransTdcDelChannelInfo002, TestSize.Level1)
743 {
744 int32_t channelId = 1;
745 int32_t errCode = 1;
746 TcpDirectChannelInfo *info = (TcpDirectChannelInfo *)SoftBusCalloc(sizeof(TcpDirectChannelInfo));
747 ASSERT_TRUE(info != nullptr);
748
749 g_tcpDirectChannelInfoList = CreateSoftBusList();
750 ASSERT_TRUE(g_tcpDirectChannelInfoList != nullptr);
751 info->channelId = channelId;
752
753 (void)SoftBusMutexLock(&g_tcpDirectChannelInfoList->lock);
754 ListAdd(&g_tcpDirectChannelInfoList->list, &info->node);
755 (void)SoftBusMutexUnlock(&g_tcpDirectChannelInfoList->lock);
756 TransTdcDelChannelInfo(channelId, errCode);
757 // info is deleted in the abnormal branch
758 DestroySoftBusList(g_tcpDirectChannelInfoList);
759 g_tcpDirectChannelInfoList = nullptr;
760 }
761
762 /**
763 * @tc.name: TransUpdateFdState001
764 * @tc.desc: TransUpdateFdState, use the wrong parameter.
765 * @tc.type: FUNC
766 * @tc.require:I5HQGA
767 */
768 HWTEST_F(TransSdkTcpDirectTest, TransUpdateFdState001, TestSize.Level1)
769 {
770 int32_t channelId1 = 1;
771 int32_t channelId2 = 2;
772 int32_t fdRefCnt = 3;
773 TransUpdateFdState(channelId1);
774 EXPECT_TRUE(g_tcpDirectChannelInfoList == nullptr);
775
776 TcpDirectChannelInfo *info = (TcpDirectChannelInfo *)SoftBusCalloc(sizeof(TcpDirectChannelInfo));
777 ASSERT_TRUE(info != nullptr);
778
779 g_tcpDirectChannelInfoList = CreateSoftBusList();
780 ASSERT_TRUE(g_tcpDirectChannelInfoList != nullptr);
781
782 info->channelId = channelId1;
783 info->detail.fdRefCnt = fdRefCnt;
784 info->detail.needRelease = true;
785 (void)SoftBusMutexLock(&g_tcpDirectChannelInfoList->lock);
786 ListAdd(&g_tcpDirectChannelInfoList->list, &info->node);
787 (void)SoftBusMutexUnlock(&g_tcpDirectChannelInfoList->lock);
788
789 TransUpdateFdState(channelId2);
790 EXPECT_TRUE(info->detail.fdRefCnt == fdRefCnt);
791 TransUpdateFdState(channelId1);
792 EXPECT_TRUE(info != nullptr);
793 info->detail.needRelease = false;
794 TransUpdateFdState(channelId1);
795 EXPECT_TRUE(info != nullptr);
796 TransUpdateFdState(channelId1);
797
798 SoftBusFree(info);
799 DestroySoftBusList(g_tcpDirectChannelInfoList);
800 g_tcpDirectChannelInfoList = nullptr;
801 }
802
803 /**
804 * @tc.name: TransTdcCloseChannelTest003
805 * @tc.desc: TransTdcCloseChannel, use the wrong parameter.
806 * @tc.type: FUNC
807 * @tc.require:I5HQGA
808 */
809 HWTEST_F(TransSdkTcpDirectTest, TransTdcCloseChannelTest003, TestSize.Level1)
810 {
811 int32_t channelId = 1;
812 ChannelInfo *channel = TestGetChannelInfo();
813 ASSERT_TRUE(channel != nullptr);
814
815 TransTdcManagerInit(&g_sessionCb);
816
817 g_tcpDirectChannelInfoList = CreateSoftBusList();
818 ASSERT_TRUE(g_tcpDirectChannelInfoList != nullptr);
819
820 TcpDirectChannelInfo *info = (TcpDirectChannelInfo *)SoftBusCalloc(sizeof(TcpDirectChannelInfo));
821 ASSERT_TRUE(info != nullptr);
822
823 info->channelId = channelId;
824 info->detail.fdRefCnt = 0;
825 (void)SoftBusMutexLock(&g_tcpDirectChannelInfoList->lock);
826 ListAdd(&g_tcpDirectChannelInfoList->list, &info->node);
827 (void)SoftBusMutexUnlock(&g_tcpDirectChannelInfoList->lock);
828
829 TransTdcCloseChannel(channelId);
830 // info is deleted in the abnormal branch
831 SoftBusFree(channel);
832 if (g_tcpDirectChannelInfoList != nullptr) {
833 DestroySoftBusList(g_tcpDirectChannelInfoList);
834 g_tcpDirectChannelInfoList = nullptr;
835 }
836 }
837
838 /**
839 * @tc.name: TransDisableSessionListenerTest006
840 * @tc.desc: TransDisableSessionListener, use the wrong parameter.
841 * @tc.type: FUNC
842 * @tc.require:I5HQGA
843 */
844 HWTEST_F(TransSdkTcpDirectTest, TransDisableSessionListenerTest006, TestSize.Level1)
845 {
846 int32_t channelId = 1;
847 int32_t errFd = -1;
848 g_tcpDirectChannelInfoList = CreateSoftBusList();
849 ASSERT_TRUE(g_tcpDirectChannelInfoList != nullptr);
850
851 TcpDirectChannelInfo *info = (TcpDirectChannelInfo *)SoftBusCalloc(sizeof(TcpDirectChannelInfo));
852 ASSERT_TRUE(info != nullptr);
853
854 info->channelId = channelId;
855 info->detail.fd = errFd;
856 (void)SoftBusMutexLock(&g_tcpDirectChannelInfoList->lock);
857 ListAdd(&g_tcpDirectChannelInfoList->list, &info->node);
858 (void)SoftBusMutexUnlock(&g_tcpDirectChannelInfoList->lock);
859
860 int32_t ret = TransDisableSessionListener(channelId);
861 EXPECT_EQ(ret, SOFTBUS_INVALID_FD);
862 info->detail.fd = g_fd;
863
864 ret = TransDisableSessionListener(channelId);
865 EXPECT_EQ(ret, SOFTBUS_OK);
866
867 SoftBusFree(info);
868 }
869
870 /**
871 * @tc.name: TransDisableSessionListenerTest007
872 * @tc.desc: TransDisableSessionListener, use the wrong parameter.
873 * @tc.type: FUNC
874 * @tc.require:I5HQGA
875 */
876 HWTEST_F(TransSdkTcpDirectTest, TransDisableSessionListenerTest007, TestSize.Level1)
877 {
878 int32_t channelId = 1;
879 g_tcpDirectChannelInfoList = CreateSoftBusList();
880 ASSERT_TRUE(g_tcpDirectChannelInfoList != nullptr);
881
882 TcpDirectChannelInfo *info = (TcpDirectChannelInfo *)SoftBusCalloc(sizeof(TcpDirectChannelInfo));
883 ASSERT_TRUE(info != nullptr);
884
885 info->channelId = channelId;
886 info->detail.fd = g_fd;
887 (void)SoftBusMutexLock(&g_tcpDirectChannelInfoList->lock);
888 ListAdd(&g_tcpDirectChannelInfoList->list, &info->node);
889 (void)SoftBusMutexUnlock(&g_tcpDirectChannelInfoList->lock);
890
891 int32_t ret = TransDisableSessionListener(channelId);
892 EXPECT_EQ(ret, SOFTBUS_OK);
893
894 SoftBusFree(info);
895 }
896
897 /**
898 * @tc.name: TransTdcGetInfoByIdTest007
899 * @tc.desc: TransTdcGetInfoById, use the wrong parameter.
900 * @tc.type: FUNC
901 * @tc.require:I5HQGA
902 */
903 HWTEST_F(TransSdkTcpDirectTest, TransTdcGetInfoByIdTest007, TestSize.Level1)
904 {
905 int32_t channelId = 1;
906 TcpDirectChannelInfo *info = (TcpDirectChannelInfo *)SoftBusCalloc(sizeof(TcpDirectChannelInfo));
907 ASSERT_TRUE(info != nullptr);
908
909 g_tcpDirectChannelInfoList = CreateSoftBusList();
910 ASSERT_TRUE(g_tcpDirectChannelInfoList != nullptr);
911
912 info->channelId = channelId;
913 (void)SoftBusMutexLock(&g_tcpDirectChannelInfoList->lock);
914 ListAdd(&g_tcpDirectChannelInfoList->list, &info->node);
915 (void)SoftBusMutexUnlock(&g_tcpDirectChannelInfoList->lock);
916
917 int32_t item = TransTdcGetInfoById(1, info);
918 EXPECT_EQ(item, SOFTBUS_OK);
919
920 SoftBusFree(info);
921 DestroySoftBusList(g_tcpDirectChannelInfoList);
922 g_tcpDirectChannelInfoList = nullptr;
923 }
924
925 /**
926 * @tc.name: TransTdcSetListenerStateById001
927 * @tc.desc: TransTdcSetListenerStateById, use the wrong parameter.
928 * @tc.type: FUNC
929 * @tc.require:I5HQGA
930 */
931 HWTEST_F(TransSdkTcpDirectTest, TransTdcSetListenerStateById001, TestSize.Level1)
932 {
933 int32_t channelId = 1;
934 int32_t invalidChannelId = 2;
935 int32_t ret = TransTdcSetListenerStateById(1, true);
936 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
937
938 TcpDirectChannelInfo *info = (TcpDirectChannelInfo *)SoftBusCalloc(sizeof(TcpDirectChannelInfo));
939 ASSERT_TRUE(info != nullptr);
940
941 g_tcpDirectChannelInfoList = CreateSoftBusList();
942 ASSERT_TRUE(g_tcpDirectChannelInfoList != nullptr);
943
944 info->channelId = channelId;
945 info->detail.needStopListener = false;
946 (void)SoftBusMutexLock(&g_tcpDirectChannelInfoList->lock);
947 ListAdd(&g_tcpDirectChannelInfoList->list, &info->node);
948 (void)SoftBusMutexUnlock(&g_tcpDirectChannelInfoList->lock);
949
950 ret = TransTdcSetListenerStateById(channelId, true);
951 EXPECT_TRUE(ret == SOFTBUS_OK);
952
953 ret = TransTdcSetListenerStateById(invalidChannelId, true);
954 EXPECT_TRUE(ret == SOFTBUS_NOT_FIND);
955
956 ret = TransTdcSetListenerStateById(channelId, false);
957 EXPECT_TRUE(ret == SOFTBUS_OK);
958
959 SoftBusFree(info);
960 DestroySoftBusList(g_tcpDirectChannelInfoList);
961 g_tcpDirectChannelInfoList = nullptr;
962 }
963
964 /**
965 * @tc.name: TransTdcGetInfoByFdTest001
966 * @tc.desc: TransTdcGetInfoByFd, use the wrong parameter.
967 * @tc.type: FUNC
968 * @tc.require:I5HQGA
969 */
970 HWTEST_F(TransSdkTcpDirectTest, TransTdcGetInfoByFdTest001, TestSize.Level1)
971 {
972 int32_t testFd = 123;
973 TcpDirectChannelInfo *info = (TcpDirectChannelInfo *)SoftBusCalloc(sizeof(TcpDirectChannelInfo));
974 ASSERT_TRUE(info != nullptr);
975
976 ChannelInfo *channel = TestGetChannelInfo();
977 ASSERT_TRUE(channel != nullptr);
978
979 g_tcpDirectChannelInfoList = CreateSoftBusList();
980 ASSERT_TRUE(g_tcpDirectChannelInfoList != nullptr);
981
982 info->detail.fd = testFd;
983 (void)SoftBusMutexLock(&g_tcpDirectChannelInfoList->lock);
984 ListAdd(&g_tcpDirectChannelInfoList->list, &info->node);
985 (void)SoftBusMutexUnlock(&g_tcpDirectChannelInfoList->lock);
986
987 int32_t item = TransTdcGetInfoByFd(testFd, info);
988 EXPECT_EQ(item, SOFTBUS_OK);
989
990 SoftBusFree(info);
991 SoftBusFree(channel);
992 DestroySoftBusList(g_tcpDirectChannelInfoList);
993 g_tcpDirectChannelInfoList = nullptr;
994 }
995
996 /**
997 * @tc.name: TransTdcGetInfoByIdWithIncSeqTest001
998 * @tc.desc: TransTdcGetInfoIncFdRefById, use the wrong parameter.
999 * @tc.type: FUNC
1000 * @tc.require:I5HQGA
1001 */
1002 HWTEST_F(TransSdkTcpDirectTest, TransTdcGetInfoByIdWithIncSeqTest001, TestSize.Level1)
1003 {
1004 int32_t channelId = 1;
1005 TcpDirectChannelInfo *info = (TcpDirectChannelInfo *)SoftBusCalloc(sizeof(TcpDirectChannelInfo));
1006 ASSERT_TRUE(info != nullptr);
1007
1008 ChannelInfo *channel = TestGetChannelInfo();
1009 ASSERT_TRUE(channel != nullptr);
1010
1011 g_tcpDirectChannelInfoList = CreateSoftBusList();
1012 ASSERT_TRUE(g_tcpDirectChannelInfoList != nullptr);
1013
1014 info->channelId = channelId;
1015 (void)SoftBusMutexLock(&g_tcpDirectChannelInfoList->lock);
1016 ListAdd(&g_tcpDirectChannelInfoList->list, &info->node);
1017 (void)SoftBusMutexUnlock(&g_tcpDirectChannelInfoList->lock);
1018
1019 TcpDirectChannelInfo *item = TransTdcGetInfoIncFdRefById(channelId, info, true);
1020 EXPECT_TRUE(item != nullptr);
1021
1022 SoftBusFree(info);
1023 SoftBusFree(channel);
1024 DestroySoftBusList(g_tcpDirectChannelInfoList);
1025 g_tcpDirectChannelInfoList = nullptr;
1026 }
1027
1028 /**
1029 * @tc.name: GetFdByPeerIpAndPortTest001
1030 * @tc.desc: test GetFdByPeerIpAndPort function.
1031 * @tc.type: FUNC
1032 * @tc.require:
1033 */
1034 HWTEST_F(TransSdkTcpDirectTest, GetFdByPeerIpAndPortTest001, TestSize.Level1)
1035 {
1036 int32_t channelId = 1;
1037 TcpDirectChannelInfo *info = (TcpDirectChannelInfo *)SoftBusCalloc(sizeof(TcpDirectChannelInfo));
1038 ASSERT_TRUE(info != nullptr);
1039 (void)strcpy_s(info->detail.peerIp, sizeof(info->detail.peerIp), "127.0.0.1");
1040 info->detail.peerPort = 1234;
1041 info->detail.fd = 123;
1042 info->channelId = channelId;
1043
1044 g_tcpDirectChannelInfoList = CreateSoftBusList();
1045 ASSERT_TRUE(g_tcpDirectChannelInfoList != nullptr);
1046 (void)SoftBusMutexLock(&g_tcpDirectChannelInfoList->lock);
1047 ListAdd(&g_tcpDirectChannelInfoList->list, &info->node);
1048 (void)SoftBusMutexUnlock(&g_tcpDirectChannelInfoList->lock);
1049
1050 int32_t fd = -1;
1051 int32_t ret = GetFdByPeerIpAndPort("127.0.0.1", 1234, &fd);
1052 EXPECT_EQ(ret, SOFTBUS_OK);
1053 EXPECT_EQ(fd, 123);
1054 ret = GetFdByPeerIpAndPort("127.0.0.1", 1235, &fd);
1055 EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
1056
1057 SoftBusFree(info);
1058 DestroySoftBusList(g_tcpDirectChannelInfoList);
1059 g_tcpDirectChannelInfoList = nullptr;
1060 }
1061
1062 /**
1063 * @tc.name: TransStartTimeSyncTest001
1064 * @tc.desc: test TransStartTimeSync function.
1065 * @tc.type: FUNC
1066 * @tc.require:
1067 */
1068 HWTEST_F(TransSdkTcpDirectTest, OnTimeSyncResultByIpTest001, TestSize.Level1)
1069 {
1070 ChannelInfo channel;
1071 channel.peerIp = nullptr;
1072 int32_t ret = TransStartTimeSync(&channel);
1073 EXPECT_EQ(ret, SOFTBUS_STRCPY_ERR);
1074 channel.peerIp = (char *)"127.0.0.1";
1075 channel.peerDeviceId = nullptr;
1076 ret = TransStartTimeSync(&channel);
1077 EXPECT_EQ(ret, SOFTBUS_STRCPY_ERR);
1078 channel.peerDeviceId = (char *)"1234567890";
1079 channel.pkgName = nullptr;
1080 ret = TransStartTimeSync(&channel);
1081 EXPECT_NE(ret, SOFTBUS_OK);
1082 channel.pkgName = (char *)"test";
1083 ret = TransStartTimeSync(&channel);
1084
1085 OnTimeSyncResultByIp(nullptr, -1);
1086 OnTimeSyncResultByIp(nullptr, SOFTBUS_OK);
1087 TimeSyncResultWithSocket info;
1088 (void)strcpy_s(info.targetSocketInfo.peerIp, sizeof(info.targetSocketInfo.peerIp), "127.0.0.1");
1089 info.targetSocketInfo.peerPort = 1234;
1090 OnTimeSyncResultByIp(&info, SOFTBUS_OK);
1091 }
1092
1093 /**
1094 * @tc.name: TransStopTimeSyncTest001
1095 * @tc.desc: test TransStopTimeSync function.
1096 * @tc.type: FUNC
1097 * @tc.require:
1098 */
1099 HWTEST_F(TransSdkTcpDirectTest, TransStopTimeSyncTest001, TestSize.Level1)
1100 {
1101 int32_t ret = TransStopTimeSync(0);
1102 EXPECT_NE(ret, SOFTBUS_OK);
1103
1104 int32_t channelId = 1;
1105 TcpDirectChannelInfo *info = (TcpDirectChannelInfo *)SoftBusCalloc(sizeof(TcpDirectChannelInfo));
1106 ASSERT_TRUE(info != nullptr);
1107 (void)strcpy_s(info->detail.peerIp, sizeof(info->detail.peerIp), "127.0.0.1");
1108 info->detail.peerPort = 1234;
1109 info->detail.fd = 123;
1110 info->channelId = channelId;
1111 info->detail.fdProtocol = LNN_PROTOCOL_IP;
1112 (void)strcpy_s(info->detail.peerDeviceId, sizeof(info->detail.peerDeviceId), "1234567890");
1113 g_tcpDirectChannelInfoList = CreateSoftBusList();
1114 ASSERT_TRUE(g_tcpDirectChannelInfoList != nullptr);
1115 (void)SoftBusMutexLock(&g_tcpDirectChannelInfoList->lock);
1116 ListAdd(&g_tcpDirectChannelInfoList->list, &info->node);
1117 (void)SoftBusMutexUnlock(&g_tcpDirectChannelInfoList->lock);
1118
1119 ret = TransStopTimeSync(channelId);
1120 EXPECT_EQ(ret, SOFTBUS_OK);
1121
1122 info->detail.fdProtocol = LNN_PROTOCOL_MINTP;
1123 ret = TransStopTimeSync(channelId);
1124 EXPECT_NE(ret, SOFTBUS_OK);
1125 SoftBusFree(info);
1126 DestroySoftBusList(g_tcpDirectChannelInfoList);
1127 g_tcpDirectChannelInfoList = nullptr;
1128 }
1129 } // namespace OHOS
1130