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
92
OnSessionOpened(const char * sessionName,const ChannelInfo * channel,SessionType flag)93 static int32_t OnSessionOpened(const char *sessionName, const ChannelInfo *channel, SessionType flag)
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 ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
153 EXPECT_EQ(ret, SOFTBUS_OK);
154 ret = InitBaseListener();
155 EXPECT_EQ(ret, SOFTBUS_OK);
156 }
157
TearDownTestCase(void)158 void TransSdkTcpDirectTest::TearDownTestCase(void)
159 {
160 TransTdcManagerDeinit();
161 }
162
163 /**
164 * @tc.name: ClientTransTdcOnChannelOpenedTest001
165 * @tc.desc: ClientTransTdcOnChannelOpened, use the wrong parameter.
166 * @tc.type: FUNC
167 * @tc.require:I5HQGA
168 */
169 HWTEST_F(TransSdkTcpDirectTest, ClientTransTdcOnChannelOpenedTest001, TestSize.Level0)
170 {
171 ChannelInfo *channel = TestGetChannelInfo();
172 ASSERT_TRUE(channel != nullptr);
173 int32_t ret = ClientTransTdcOnChannelOpened(nullptr, channel);
174 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
175
176 ret = ClientTransTdcOnChannelOpened(g_sessionName, nullptr);
177 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
178
179 ret = ClientTransTdcOnChannelOpened(g_sessionName, channel);
180 EXPECT_EQ(ret, SOFTBUS_MEM_ERR);
181
182 SoftBusFree(channel);
183 }
184
185 /**
186 * @tc.name: TransTdcCloseChannelTest002
187 * @tc.desc: TransTdcCloseChannel, use the wrong parameter.
188 * @tc.type: FUNC
189 * @tc.require:I5HQGA
190 */
191 HWTEST_F(TransSdkTcpDirectTest, TransTdcCloseChannelTest002, TestSize.Level0)
192 {
193 int32_t channelId = 1;
194 ChannelInfo *channel = TestGetChannelInfo();
195 ASSERT_TRUE(channel != nullptr);
196
197 TransTdcManagerInit(&g_sessionCb);
198
199 TransTdcCloseChannel(channelId);
200
201 int32_t ret = ClientTransTdcOnChannelOpened(g_sessionName, channel);
202 EXPECT_EQ(ret, SOFTBUS_MEM_ERR);
203
204 TransTdcCloseChannel(channelId);
205
206 channelId = INVALID_VALUE;
207 TransTdcCloseChannel(channelId);
208
209 SoftBusFree(channel);
210 }
211
212 /**
213 * @tc.name: TransTdcGetSessionKeyTest003
214 * @tc.desc: TransTdcGetSessionKey, use the wrong parameter.
215 * @tc.type: FUNC
216 * @tc.require:I5HQGA
217 */
218 HWTEST_F(TransSdkTcpDirectTest, TransTdcGetSessionKeyTest003, TestSize.Level0)
219 {
220 int32_t channelId = 1;
221 unsigned int len = 32;
222 ChannelInfo *channel = TestGetChannelInfo();
223 ASSERT_TRUE(channel != nullptr);
224
225 int32_t ret = ClientTransTdcOnChannelOpened(g_sessionName, channel);
226 EXPECT_EQ(ret, SOFTBUS_MEM_ERR);
227
228 ret = TransTdcGetSessionKey(channelId, nullptr, len);
229 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
230
231 ret = TransTdcGetSessionKey(channelId, const_cast<char *>(g_sessionkey), len);
232 EXPECT_EQ(ret, SOFTBUS_TRANS_TDC_CHANNEL_NOT_FOUND);
233
234 channelId = INVALID_VALUE;
235 ret = TransTdcGetSessionKey(channelId, const_cast<char *>(g_sessionkey), len);
236 EXPECT_EQ(ret, SOFTBUS_TRANS_TDC_CHANNEL_NOT_FOUND);
237
238 SoftBusFree(channel);
239 }
240
241 /**
242 * @tc.name: TransTdcGetHandleTest004
243 * @tc.desc: TransTdcGetHandle, use the wrong parameter.
244 * @tc.type: FUNC
245 * @tc.require:I5HQGA
246 */
247 HWTEST_F(TransSdkTcpDirectTest, TransTdcGetHandleTest004, TestSize.Level0)
248 {
249 int32_t channelId = 1;
250 int32_t handle = 0;
251 ChannelInfo *channel = TestGetChannelInfo();
252 ASSERT_TRUE(channel != nullptr);
253
254 int32_t ret = ClientTransTdcOnChannelOpened(g_sessionName, channel);
255 EXPECT_EQ(ret, SOFTBUS_MEM_ERR);
256
257 ret = TransTdcGetHandle(channelId, nullptr);
258 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
259
260 ret = TransTdcGetHandle(channelId, &handle);
261 EXPECT_EQ(ret, SOFTBUS_TRANS_TDC_CHANNEL_NOT_FOUND);
262
263 channelId = INVALID_VALUE;
264 ret = TransTdcGetHandle(channelId, &handle);
265 EXPECT_EQ(ret, SOFTBUS_TRANS_TDC_CHANNEL_NOT_FOUND);
266
267 SoftBusFree(channel);
268 }
269
270 /**
271 * @tc.name: TransDisableSessionListenerTest005
272 * @tc.desc: TransDisableSessionListener, use the wrong parameter.
273 * @tc.type: FUNC
274 * @tc.require:I5HQGA
275 */
276
277 HWTEST_F(TransSdkTcpDirectTest, TransDisableSessionListenerTest005, TestSize.Level0)
278 {
279 int32_t channelId = 1;
280
281 ChannelInfo *info = (ChannelInfo *)SoftBusCalloc(sizeof(ChannelInfo));
282 ASSERT_TRUE(info != nullptr);
283 (void)memset_s(info, sizeof(ChannelInfo), 0, sizeof(ChannelInfo));
284 info->peerSessionName = const_cast<char *>(g_sessionName);
285 info->channelId = 1;
286 info->channelType = CHANNEL_TYPE_TCP_DIRECT;
287 info->sessionKey = const_cast<char *>(g_sessionkey);
288 info->fd = INVALID_VALUE;
289
290 int32_t ret = ClientTransTdcOnChannelOpened(g_sessionName, info);
291 EXPECT_EQ(ret, SOFTBUS_MEM_ERR);
292
293 info->fd = g_fd;
294 ret = TransDisableSessionListener(channelId);
295 EXPECT_EQ(ret, SOFTBUS_TRANS_TDC_CHANNEL_NOT_FOUND);
296
297 ret = TransDisableSessionListener(channelId);
298 EXPECT_EQ(ret, SOFTBUS_TRANS_TDC_CHANNEL_NOT_FOUND);
299
300 channelId = INVALID_VALUE;
301 ret = TransDisableSessionListener(channelId);
302 EXPECT_EQ(ret, SOFTBUS_TRANS_TDC_CHANNEL_NOT_FOUND);
303
304 SoftBusFree(info);
305 }
306
307 /**
308 * @tc.name: TransTdcGetInfoByIdTest006
309 * @tc.desc: TransTdcGetInfoById, use the wrong parameter.
310 * @tc.type: FUNC
311 * @tc.require:I5HQGA
312 */
313 HWTEST_F(TransSdkTcpDirectTest, TransTdcGetInfoByIdTest006, TestSize.Level0)
314 {
315 int32_t channelId = 1;
316 TcpDirectChannelInfo *info = (TcpDirectChannelInfo *)SoftBusMalloc(sizeof(TcpDirectChannelInfo));
317 ASSERT_TRUE(info != nullptr);
318 (void)memset_s(info, sizeof(TcpDirectChannelInfo), 0, sizeof(TcpDirectChannelInfo));
319
320 ChannelInfo *channel = TestGetChannelInfo();
321 ASSERT_TRUE(channel != nullptr);
322 int32_t ret = ClientTransTdcOnChannelOpened(g_sessionName, channel);
323 EXPECT_EQ(ret, SOFTBUS_MEM_ERR);
324
325 int32_t item = TransTdcGetInfoById(channelId, nullptr);
326 EXPECT_NE(item, SOFTBUS_OK);
327
328 item = TransTdcGetInfoById(channelId, info);
329 EXPECT_NE(item, SOFTBUS_OK);
330
331 channelId = INVALID_VALUE;
332 item = TransTdcGetInfoById(channelId, info);
333 EXPECT_NE(item, SOFTBUS_OK);
334
335 SoftBusFree(info);
336 SoftBusFree(channel);
337 }
338
339 /**
340 * @tc.name: TransTdcGetInfoByFdTest007
341 * @tc.desc: TransTdcGetInfoByFd, use the wrong parameter.
342 * @tc.type: FUNC
343 * @tc.require:I5HQGA
344 */
345 HWTEST_F(TransSdkTcpDirectTest, TransTdcGetInfoByFdTest007, TestSize.Level0)
346 {
347 int32_t fd = g_fd;
348 TcpDirectChannelInfo *info = (TcpDirectChannelInfo *)SoftBusMalloc(sizeof(TcpDirectChannelInfo));
349 ASSERT_TRUE(info != nullptr);
350 (void)memset_s(info, sizeof(TcpDirectChannelInfo), 0, sizeof(TcpDirectChannelInfo));
351
352 ChannelInfo *channel = TestGetChannelInfo();
353 ASSERT_TRUE(channel != nullptr);
354 int32_t ret = ClientTransTdcOnChannelOpened(g_sessionName, channel);
355 EXPECT_EQ(ret, SOFTBUS_MEM_ERR);
356
357 int32_t item = TransTdcGetInfoByFd(fd, nullptr);
358 EXPECT_NE(item, SOFTBUS_OK);
359
360 item = TransTdcGetInfoByFd(fd, info);
361 EXPECT_NE(item, SOFTBUS_OK);
362
363 fd = 1;
364 item = TransTdcGetInfoByFd(fd, info);
365 EXPECT_NE(item, SOFTBUS_OK);
366
367 SoftBusFree(info);
368 SoftBusFree(channel);
369 }
370
371 /**
372 * @tc.name: TransTdcGetInfoByIdWithIncSeqTest008
373 * @tc.desc: TransTdcGetInfoIncFdRefById, use the wrong parameter.
374 * @tc.type: FUNC
375 * @tc.require:I5HQGA
376 */
377 HWTEST_F(TransSdkTcpDirectTest, TransTdcGetInfoByIdWithIncSeqTest008, TestSize.Level0)
378 {
379 int32_t channelId = 1;
380 TcpDirectChannelInfo *info = (TcpDirectChannelInfo *)SoftBusMalloc(sizeof(TcpDirectChannelInfo));
381 ASSERT_TRUE(info != nullptr);
382 (void)memset_s(info, sizeof(TcpDirectChannelInfo), 0, sizeof(TcpDirectChannelInfo));
383
384 ChannelInfo *channel = TestGetChannelInfo();
385 ASSERT_TRUE(channel != nullptr);
386 int32_t ret = ClientTransTdcOnChannelOpened(g_sessionName, channel);
387 EXPECT_EQ(ret, SOFTBUS_MEM_ERR);
388
389 TcpDirectChannelInfo *item = TransTdcGetInfoIncFdRefById(channelId, nullptr, true);
390 EXPECT_TRUE(item == nullptr);
391
392 item = TransTdcGetInfoIncFdRefById(channelId, info, true);
393 EXPECT_TRUE(item == nullptr);
394
395 channelId = INVALID_VALUE;
396 item = TransTdcGetInfoIncFdRefById(channelId, info, true);
397 EXPECT_TRUE(item == nullptr);
398
399 SoftBusFree(info);
400 SoftBusFree(channel);
401 }
402
403 /**
404 * @tc.name: ClientTransTdcSetCallBackTest009
405 * @tc.desc: ClientTransTdcSetCallBack, use the wrong parameter.
406 * @tc.type: FUNC
407 * @tc.require:I5HQGA
408 */
409 HWTEST_F(TransSdkTcpDirectTest, ClientTransTdcSetCallBackTest009, TestSize.Level0)
410 {
411 const IClientSessionCallBack *cb = GetClientSessionCb();
412 int32_t ret = ClientTransTdcSetCallBack(nullptr);
413 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
414 ret = ClientTransTdcSetCallBack(cb);
415 EXPECT_EQ(ret, SOFTBUS_OK);
416 }
417
418 /**
419 * @tc.name: ClientTransTdcOnSessionOpenedTest0010
420 * @tc.desc: ClientTransTdcOnSessionOpened, use the wrong parameter.
421 * @tc.type: FUNC
422 * @tc.require:I5HQGA
423 */
424 HWTEST_F(TransSdkTcpDirectTest, ClientTransTdcOnSessionOpenedTest0010, TestSize.Level0)
425 {
426 ChannelInfo *info = (ChannelInfo *)SoftBusCalloc(sizeof(ChannelInfo));
427 ASSERT_TRUE(info != nullptr);
428 (void)memset_s(info, sizeof(ChannelInfo), 0, sizeof(ChannelInfo));
429
430 int32_t ret = ClientTransTdcSetCallBack(&g_sessionCb);
431 ret = ClientTransTdcOnSessionOpened(g_sessionName, nullptr);
432 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
433
434 info->isServer = true;
435 info->channelType = CHANNEL_TYPE_AUTH;
436 ret = ClientTransTdcOnSessionOpened(nullptr, info);
437 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
438
439 ret = ClientTransTdcOnSessionOpened(g_sessionName, info);
440 EXPECT_EQ(ret, SOFTBUS_OK);
441
442 info->isServer = false;
443 info->channelType = CHANNEL_TYPE_UDP;
444 ret = ClientTransTdcOnSessionOpened(g_sessionName, info);
445 EXPECT_EQ(ret, SOFTBUS_OK);
446 SoftBusFree(info);
447 }
448
449 /**
450 * @tc.name: ClientTransTdcOnSessionClosedTest0011
451 * @tc.desc: ClientTransTdcOnSessionClosed, use the wrong parameter.
452 * @tc.type: FUNC
453 * @tc.require:I5HQGA
454 */
455 HWTEST_F(TransSdkTcpDirectTest, ClientTransTdcOnSessionClosedTest0011, TestSize.Level0)
456 {
457 int32_t channelId = 1;
458 int32_t errCode = SOFTBUS_OK;
459 int32_t ret = ClientTransTdcSetCallBack(&g_sessionCb);
460 ret = ClientTransTdcOnSessionClosed(channelId, SHUTDOWN_REASON_UNKNOWN);
461 EXPECT_EQ(ret, SOFTBUS_OK);
462
463 ret = ClientTransTdcOnSessionOpenFailed(channelId, errCode);
464 EXPECT_EQ(ret, SOFTBUS_OK);
465
466 const char *data = "client";
467 uint32_t len = strlen(data);
468 ret = ClientTransTdcOnDataReceived(channelId, (void *)data, len, TRANS_SESSION_FILE_ONLYONE_FRAME);
469 EXPECT_EQ(ret, SOFTBUS_OK);
470 }
471
472 /**
473 * @tc.name: TransTdcCreateListenerTest0012
474 * @tc.desc: TransTdcCreateListener, use the wrong parameter.
475 * @tc.type: FUNC
476 * @tc.require:I5HQGA
477 */
478 HWTEST_F(TransSdkTcpDirectTest, TransTdcCreateListenerTest0012, TestSize.Level0)
479 {
480 int32_t fd = INVALID_VALUE;
481 int32_t ret = TransTdcCreateListener(fd);
482 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
483 fd = g_fd;
484 ret = TransTdcCreateListener(fd);
485 EXPECT_EQ(ret, SOFTBUS_OK);
486 }
487
488 /**
489 * @tc.name: TransTdcReleaseFdTest0013
490 * @tc.desc: TransTdcReleaseFd, use the wrong parameter.
491 * @tc.type: FUNC
492 * @tc.require:I5HQGA
493 */
494 HWTEST_F(TransSdkTcpDirectTest, TransTdcReleaseFdTest0013, TestSize.Level0)
495 {
496 int32_t fd = INVALID_VALUE;
497 TransTdcReleaseFd(fd);
498 EXPECT_EQ(fd, INVALID_VALUE);
499 fd = g_fd;
500 TransTdcReleaseFd(fd);
501 EXPECT_TRUE(g_fd == fd);
502 }
503
504 /**
505 * @tc.name: TransTdcStopReadTest0014
506 * @tc.desc: TransTdcStopRead, use the wrong parameter.
507 * @tc.type: FUNC
508 * @tc.require:I5HQGA
509 */
510 HWTEST_F(TransSdkTcpDirectTest, TransTdcStopReadTest0014, TestSize.Level0)
511 {
512 int32_t fd = INVALID_VALUE;
513 int32_t ret = TransTdcStopRead(fd);
514 EXPECT_EQ(ret, SOFTBUS_OK);
515 fd = g_fd + 1;
516 ret = TransTdcCreateListener(fd);
517 EXPECT_EQ(ret, SOFTBUS_OK);
518 ret = TransTdcStopRead(fd);
519 EXPECT_EQ(ret, SOFTBUS_OK);
520 ret = TransTdcStopRead(fd);
521 EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
522 }
523
524 /**
525 * @tc.name: ClientTransTdcOnChannelOpenFailedTest0015
526 * @tc.desc: ClientTransTdcOnChannelOpenFailed, use the wrong parameter.
527 * @tc.type: FUNC
528 * @tc.require:I5HQGA
529 */
530 HWTEST_F(TransSdkTcpDirectTest, ClientTransTdcOnChannelOpenFailedTest0015, TestSize.Level0)
531 {
532 int32_t channelId = 1;
533 int32_t errCode = SOFTBUS_OK;
534 int32_t ret = ClientTransTdcOnChannelOpenFailed(channelId, errCode);
535 EXPECT_EQ(ret, SOFTBUS_OK);
536
537 channelId = INVALID_VALUE;
538 ret = ClientTransTdcOnChannelOpenFailed(channelId, errCode);
539 EXPECT_EQ(ret, SOFTBUS_OK);
540 }
541
542 /**
543 * @tc.name: TransDataListInitTest0016
544 * @tc.desc: TransDataListInit, use the wrong parameter.
545 * @tc.type: FUNC
546 * @tc.require:I5HQGA
547 */
548 HWTEST_F(TransSdkTcpDirectTest, TransDataListInitTest0016, TestSize.Level0)
549 {
550 int32_t channelId = 1;
551 int32_t fd = 1;
552 TransDataListDeinit();
553 int32_t ret = TransAddDataBufNode(channelId, fd);
554 EXPECT_EQ(ret, SOFTBUS_NO_INIT);
555
556 ret = TransDelDataBufNode(channelId);
557 EXPECT_EQ(ret, SOFTBUS_NO_INIT);
558
559 ret = TransDataListInit();
560 ASSERT_EQ(ret, SOFTBUS_OK);
561
562 ret = TransAddDataBufNode(channelId, fd);
563 ASSERT_EQ(ret, SOFTBUS_OK);
564
565 ret = TransDelDataBufNode(channelId);
566 EXPECT_EQ(ret, SOFTBUS_OK);
567
568 TransDataListDeinit();
569 }
570
571 /**
572 * @tc.name: TransTdcSendBytesTest0017
573 * @tc.desc: TransTdcSendBytes, use the wrong parameter.
574 * @tc.type: FUNC
575 * @tc.require:I5HQGA
576 */
577 HWTEST_F(TransSdkTcpDirectTest, TransTdcSendBytesTest0017, TestSize.Level0)
578 {
579 int32_t channelId = 1;
580 const char *data = "data";
581 uint32_t len = (uint32_t)strlen(data);
582 int32_t ret = TransTdcSendBytes(channelId, nullptr, len, false);
583 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
584
585 ret = TransTdcSendBytes(channelId, data, 0, false);
586 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
587
588 ret = TransTdcSendBytes(channelId, data, len, false);
589 EXPECT_EQ(ret, SOFTBUS_TRANS_TDC_GET_INFO_FAILED);
590
591 ChannelInfo *channel = TestGetChannelInfo();
592 ASSERT_TRUE(channel != nullptr);
593 ret = ClientTransTdcOnChannelOpened(g_sessionName, channel);
594 EXPECT_EQ(ret, SOFTBUS_MEM_ERR);
595
596 ret = TransTdcSendBytes(channelId, data, len, false);
597 EXPECT_EQ(ret, SOFTBUS_TRANS_TDC_GET_INFO_FAILED);
598
599 SoftBusFree(channel);
600 }
601
602 /**
603 * @tc.name: TransTdcSendMessageTest0018
604 * @tc.desc: TransTdcSendMessage, use the wrong parameter.
605 * @tc.type: FUNC
606 * @tc.require:I5HQGA
607 */
608 HWTEST_F(TransSdkTcpDirectTest, TransTdcSendMessageTest0018, TestSize.Level0)
609 {
610 int32_t channelId = 1;
611 const char *data = "data";
612 uint32_t len = (uint32_t)strlen(data);
613 int32_t ret = TransTdcSendMessage(channelId, nullptr, len);
614 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
615
616 ret = TransTdcSendMessage(channelId, data, 0);
617 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
618
619 ret = TransTdcSendMessage(channelId, data, len);
620 EXPECT_EQ(ret, SOFTBUS_TRANS_TDC_CHANNEL_NOT_FOUND);
621
622 ChannelInfo *channel = TestGetChannelInfo();
623 ASSERT_TRUE(channel != nullptr);
624 ret = ClientTransTdcOnChannelOpened(g_sessionName, channel);
625 EXPECT_EQ(ret, SOFTBUS_MEM_ERR);
626
627 ret = TransTdcSendMessage(channelId, data, len);
628 EXPECT_EQ(ret, SOFTBUS_TRANS_TDC_CHANNEL_NOT_FOUND);
629
630 SoftBusFree(channel);
631 }
632
633 /**
634 * @tc.name: TransTdcRecvDataTest0019
635 * @tc.desc: TransTdcRecvData, use the wrong parameter.
636 * @tc.type: FUNC
637 * @tc.require:I5HQGA
638 */
639 HWTEST_F(TransSdkTcpDirectTest, TransTdcRecvDataTest0019, TestSize.Level0)
640 {
641 int32_t channelId = 1;
642 int32_t fd = 1;
643 int32_t ret = TransTdcRecvData(channelId);
644 EXPECT_EQ(ret, SOFTBUS_NO_INIT);
645
646 ret = TransDataListInit();
647 ASSERT_EQ(ret, SOFTBUS_OK);
648
649 ret = TransTdcRecvData(channelId);
650 EXPECT_EQ(ret, SOFTBUS_TRANS_TDC_CHANNEL_NOT_FOUND);
651
652 ret = TransAddDataBufNode(channelId, fd);
653 ASSERT_EQ(ret, SOFTBUS_OK);
654
655 ret = TransTdcRecvData(channelId);
656 EXPECT_EQ(ret, SOFTBUS_TRANS_INVALID_DATA_LENGTH);
657 TransDataListDeinit();
658 }
659
660 /**
661 * @tc.name: TransTdcCreateListenerWithoutAddTriggerTest002
662 * @tc.desc: TransTdcCreateListenerWithoutAddTrigger, use the wrong paramter
663 * @tc.type: FUNC
664 * @tc.require:I5HQGA
665 */
666 HWTEST_F(TransSdkTcpDirectTest, TransTdcCreateListenerWithoutAddTriggerTest0020, TestSize.Level0)
667 {
668 int32_t fd = g_fd;
669 int32_t ret = TransTdcCreateListenerWithoutAddTrigger(fd);
670 EXPECT_EQ(ret, SOFTBUS_OK);
671 }
672
673 /**
674 * @tc.name: ClientTransCheckTdcChannelExist001
675 * @tc.desc: ClientTransCheckTdcChannelExist, use the wrong parameter.
676 * @tc.type: FUNC
677 * @tc.require:I5HQGA
678 */
679 HWTEST_F(TransSdkTcpDirectTest, ClientTransCheckTdcChannelExist001, TestSize.Level0)
680 {
681 int32_t channelId = 1;
682 int32_t ret = ClientTransCheckTdcChannelExist(1);
683 EXPECT_EQ(ret, SOFTBUS_OK);
684
685 TcpDirectChannelInfo *info = (TcpDirectChannelInfo *)SoftBusCalloc(sizeof(TcpDirectChannelInfo));
686 ASSERT_TRUE(info != nullptr);
687
688 g_tcpDirectChannelInfoList = CreateSoftBusList();
689 ASSERT_TRUE(g_tcpDirectChannelInfoList != nullptr);
690
691 info->channelId = channelId;
692 (void)SoftBusMutexLock(&g_tcpDirectChannelInfoList->lock);
693 ListAdd(&g_tcpDirectChannelInfoList->list, &info->node);
694 (void)SoftBusMutexUnlock(&g_tcpDirectChannelInfoList->lock);
695
696 ret = ClientTransCheckTdcChannelExist(channelId);
697 EXPECT_EQ(ret, SOFTBUS_TRANS_TDC_CHANNEL_ALREADY_EXIST);
698
699 SoftBusFree(info);
700 DestroySoftBusList(g_tcpDirectChannelInfoList);
701 g_tcpDirectChannelInfoList = nullptr;
702 }
703
704 /**
705 * @tc.name: TransTdcDelChannelInfo001
706 * @tc.desc: TransTdcDelChannelInfo, use the wrong parameter.
707 * @tc.type: FUNC
708 * @tc.require:I5HQGA
709 */
710 HWTEST_F(TransSdkTcpDirectTest, TransTdcDelChannelInfo001, TestSize.Level0)
711 {
712 int32_t channelId1 = 1;
713 int32_t channelId2 = 2;
714 TransTdcDelChannelInfo(1, SOFTBUS_TRANS_NEGOTIATE_REJECTED);
715 EXPECT_TRUE(g_tcpDirectChannelInfoList == nullptr);
716
717 TcpDirectChannelInfo *info = (TcpDirectChannelInfo *)SoftBusCalloc(sizeof(TcpDirectChannelInfo));
718 ASSERT_TRUE(info != nullptr);
719
720 g_tcpDirectChannelInfoList = CreateSoftBusList();
721 ASSERT_TRUE(g_tcpDirectChannelInfoList != nullptr);
722
723 info->channelId = channelId1;
724 (void)SoftBusMutexLock(&g_tcpDirectChannelInfoList->lock);
725 ListAdd(&g_tcpDirectChannelInfoList->list, &info->node);
726 (void)SoftBusMutexUnlock(&g_tcpDirectChannelInfoList->lock);
727
728 TransTdcDelChannelInfo(channelId2, SOFTBUS_TRANS_NEGOTIATE_REJECTED);
729 TransTdcDelChannelInfo(channelId1, SOFTBUS_TRANS_NEGOTIATE_REJECTED);
730 // info is deleted in the abnormal branch
731 DestroySoftBusList(g_tcpDirectChannelInfoList);
732 g_tcpDirectChannelInfoList = nullptr;
733 }
734
735 /**
736 * @tc.name: TransTdcDelChannelInfo002
737 * @tc.desc: TransTdcDelChannelInfo, use the wrong parameter.
738 * @tc.type: FUNC
739 * @tc.require:I5HQGA
740 */
741 HWTEST_F(TransSdkTcpDirectTest, TransTdcDelChannelInfo002, TestSize.Level0)
742 {
743 int32_t channelId = 1;
744 int32_t errCode = 1;
745 TcpDirectChannelInfo *info = (TcpDirectChannelInfo *)SoftBusCalloc(sizeof(TcpDirectChannelInfo));
746 ASSERT_TRUE(info != nullptr);
747
748 g_tcpDirectChannelInfoList = CreateSoftBusList();
749 ASSERT_TRUE(g_tcpDirectChannelInfoList != nullptr);
750 info->channelId = channelId;
751
752 (void)SoftBusMutexLock(&g_tcpDirectChannelInfoList->lock);
753 ListAdd(&g_tcpDirectChannelInfoList->list, &info->node);
754 (void)SoftBusMutexUnlock(&g_tcpDirectChannelInfoList->lock);
755 TransTdcDelChannelInfo(channelId, errCode);
756 // info is deleted in the abnormal branch
757 DestroySoftBusList(g_tcpDirectChannelInfoList);
758 g_tcpDirectChannelInfoList = nullptr;
759 }
760
761 /**
762 * @tc.name: TransUpdateFdState001
763 * @tc.desc: TransUpdateFdState, use the wrong parameter.
764 * @tc.type: FUNC
765 * @tc.require:I5HQGA
766 */
767 HWTEST_F(TransSdkTcpDirectTest, TransUpdateFdState001, TestSize.Level0)
768 {
769 int32_t channelId1 = 1;
770 int32_t channelId2 = 2;
771 int32_t fdRefCnt = 3;
772 TransUpdateFdState(channelId1);
773 EXPECT_TRUE(g_tcpDirectChannelInfoList == nullptr);
774
775 TcpDirectChannelInfo *info = (TcpDirectChannelInfo *)SoftBusCalloc(sizeof(TcpDirectChannelInfo));
776 ASSERT_TRUE(info != nullptr);
777
778 g_tcpDirectChannelInfoList = CreateSoftBusList();
779 ASSERT_TRUE(g_tcpDirectChannelInfoList != nullptr);
780
781 info->channelId = channelId1;
782 info->detail.fdRefCnt = fdRefCnt;
783 info->detail.needRelease = true;
784 (void)SoftBusMutexLock(&g_tcpDirectChannelInfoList->lock);
785 ListAdd(&g_tcpDirectChannelInfoList->list, &info->node);
786 (void)SoftBusMutexUnlock(&g_tcpDirectChannelInfoList->lock);
787
788 TransUpdateFdState(channelId2);
789 EXPECT_TRUE(info->detail.fdRefCnt == fdRefCnt);
790 TransUpdateFdState(channelId1);
791 EXPECT_TRUE(info != nullptr);
792 info->detail.needRelease = false;
793 TransUpdateFdState(channelId1);
794 EXPECT_TRUE(info != nullptr);
795 TransUpdateFdState(channelId1);
796
797 SoftBusFree(info);
798 DestroySoftBusList(g_tcpDirectChannelInfoList);
799 g_tcpDirectChannelInfoList = nullptr;
800 }
801
802 /**
803 * @tc.name: TransTdcCloseChannelTest003
804 * @tc.desc: TransTdcCloseChannel, use the wrong parameter.
805 * @tc.type: FUNC
806 * @tc.require:I5HQGA
807 */
808 HWTEST_F(TransSdkTcpDirectTest, TransTdcCloseChannelTest003, TestSize.Level0)
809 {
810 int32_t channelId = 1;
811 ChannelInfo *channel = TestGetChannelInfo();
812 ASSERT_TRUE(channel != nullptr);
813
814 TransTdcManagerInit(&g_sessionCb);
815
816 g_tcpDirectChannelInfoList = CreateSoftBusList();
817 ASSERT_TRUE(g_tcpDirectChannelInfoList != nullptr);
818
819 TcpDirectChannelInfo *info = (TcpDirectChannelInfo *)SoftBusCalloc(sizeof(TcpDirectChannelInfo));
820 ASSERT_TRUE(info != nullptr);
821
822 info->channelId = channelId;
823 info->detail.fdRefCnt = 0;
824 (void)SoftBusMutexLock(&g_tcpDirectChannelInfoList->lock);
825 ListAdd(&g_tcpDirectChannelInfoList->list, &info->node);
826 (void)SoftBusMutexUnlock(&g_tcpDirectChannelInfoList->lock);
827
828 TransTdcCloseChannel(channelId);
829 // info is deleted in the abnormal branch
830 SoftBusFree(channel);
831 if (g_tcpDirectChannelInfoList != nullptr) {
832 DestroySoftBusList(g_tcpDirectChannelInfoList);
833 g_tcpDirectChannelInfoList = nullptr;
834 }
835 }
836
837 /**
838 * @tc.name: TransDisableSessionListenerTest006
839 * @tc.desc: TransDisableSessionListener, use the wrong parameter.
840 * @tc.type: FUNC
841 * @tc.require:I5HQGA
842 */
843 HWTEST_F(TransSdkTcpDirectTest, TransDisableSessionListenerTest006, TestSize.Level0)
844 {
845 int32_t channelId = 1;
846 int32_t errFd = -1;
847 g_tcpDirectChannelInfoList = CreateSoftBusList();
848 ASSERT_TRUE(g_tcpDirectChannelInfoList != nullptr);
849
850 TcpDirectChannelInfo *info = (TcpDirectChannelInfo *)SoftBusCalloc(sizeof(TcpDirectChannelInfo));
851 ASSERT_TRUE(info != nullptr);
852
853 info->channelId = channelId;
854 info->detail.fd = errFd;
855 (void)SoftBusMutexLock(&g_tcpDirectChannelInfoList->lock);
856 ListAdd(&g_tcpDirectChannelInfoList->list, &info->node);
857 (void)SoftBusMutexUnlock(&g_tcpDirectChannelInfoList->lock);
858
859 int32_t ret = TransDisableSessionListener(channelId);
860 EXPECT_EQ(ret, SOFTBUS_INVALID_FD);
861 info->detail.fd = g_fd;
862
863 ret = TransDisableSessionListener(channelId);
864 EXPECT_EQ(ret, SOFTBUS_OK);
865
866 SoftBusFree(info);
867 }
868
869 /**
870 * @tc.name: TransDisableSessionListenerTest007
871 * @tc.desc: TransDisableSessionListener, use the wrong parameter.
872 * @tc.type: FUNC
873 * @tc.require:I5HQGA
874 */
875 HWTEST_F(TransSdkTcpDirectTest, TransDisableSessionListenerTest007, TestSize.Level0)
876 {
877 int32_t channelId = 1;
878 g_tcpDirectChannelInfoList = CreateSoftBusList();
879 ASSERT_TRUE(g_tcpDirectChannelInfoList != nullptr);
880
881 TcpDirectChannelInfo *info = (TcpDirectChannelInfo *)SoftBusCalloc(sizeof(TcpDirectChannelInfo));
882 ASSERT_TRUE(info != nullptr);
883
884 info->channelId = channelId;
885 info->detail.fd = g_fd;
886 (void)SoftBusMutexLock(&g_tcpDirectChannelInfoList->lock);
887 ListAdd(&g_tcpDirectChannelInfoList->list, &info->node);
888 (void)SoftBusMutexUnlock(&g_tcpDirectChannelInfoList->lock);
889
890 int32_t ret = TransDisableSessionListener(channelId);
891 EXPECT_EQ(ret, SOFTBUS_OK);
892
893 SoftBusFree(info);
894 }
895
896 /**
897 * @tc.name: TransTdcGetInfoByIdTest007
898 * @tc.desc: TransTdcGetInfoById, use the wrong parameter.
899 * @tc.type: FUNC
900 * @tc.require:I5HQGA
901 */
902 HWTEST_F(TransSdkTcpDirectTest, TransTdcGetInfoByIdTest007, TestSize.Level0)
903 {
904 int32_t channelId = 1;
905 TcpDirectChannelInfo *info = (TcpDirectChannelInfo *)SoftBusCalloc(sizeof(TcpDirectChannelInfo));
906 ASSERT_TRUE(info != nullptr);
907
908 g_tcpDirectChannelInfoList = CreateSoftBusList();
909 ASSERT_TRUE(g_tcpDirectChannelInfoList != nullptr);
910
911 info->channelId = channelId;
912 (void)SoftBusMutexLock(&g_tcpDirectChannelInfoList->lock);
913 ListAdd(&g_tcpDirectChannelInfoList->list, &info->node);
914 (void)SoftBusMutexUnlock(&g_tcpDirectChannelInfoList->lock);
915
916 int32_t item = TransTdcGetInfoById(1, info);
917 EXPECT_EQ(item, SOFTBUS_OK);
918
919 SoftBusFree(info);
920 DestroySoftBusList(g_tcpDirectChannelInfoList);
921 g_tcpDirectChannelInfoList = nullptr;
922 }
923
924 /**
925 * @tc.name: TransTdcSetListenerStateById001
926 * @tc.desc: TransTdcSetListenerStateById, use the wrong parameter.
927 * @tc.type: FUNC
928 * @tc.require:I5HQGA
929 */
930 HWTEST_F(TransSdkTcpDirectTest, TransTdcSetListenerStateById001, TestSize.Level0)
931 {
932 int32_t channelId = 1;
933 int32_t invalidChannelId = 2;
934 int32_t ret = TransTdcSetListenerStateById(1, true);
935 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
936
937 TcpDirectChannelInfo *info = (TcpDirectChannelInfo *)SoftBusCalloc(sizeof(TcpDirectChannelInfo));
938 ASSERT_TRUE(info != nullptr);
939
940 g_tcpDirectChannelInfoList = CreateSoftBusList();
941 ASSERT_TRUE(g_tcpDirectChannelInfoList != nullptr);
942
943 info->channelId = channelId;
944 info->detail.needStopListener = false;
945 (void)SoftBusMutexLock(&g_tcpDirectChannelInfoList->lock);
946 ListAdd(&g_tcpDirectChannelInfoList->list, &info->node);
947 (void)SoftBusMutexUnlock(&g_tcpDirectChannelInfoList->lock);
948
949 ret = TransTdcSetListenerStateById(channelId, true);
950 EXPECT_TRUE(ret == SOFTBUS_OK);
951
952 ret = TransTdcSetListenerStateById(invalidChannelId, true);
953 EXPECT_TRUE(ret == SOFTBUS_NOT_FIND);
954
955 ret = TransTdcSetListenerStateById(channelId, false);
956 EXPECT_TRUE(ret == SOFTBUS_OK);
957
958 SoftBusFree(info);
959 DestroySoftBusList(g_tcpDirectChannelInfoList);
960 g_tcpDirectChannelInfoList = nullptr;
961 }
962
963 /**
964 * @tc.name: TransTdcGetInfoByFdTest001
965 * @tc.desc: TransTdcGetInfoByFd, use the wrong parameter.
966 * @tc.type: FUNC
967 * @tc.require:I5HQGA
968 */
969 HWTEST_F(TransSdkTcpDirectTest, TransTdcGetInfoByFdTest001, TestSize.Level0)
970 {
971 int32_t testFd = 123;
972 TcpDirectChannelInfo *info = (TcpDirectChannelInfo *)SoftBusCalloc(sizeof(TcpDirectChannelInfo));
973 ASSERT_TRUE(info != nullptr);
974
975 ChannelInfo *channel = TestGetChannelInfo();
976 ASSERT_TRUE(channel != nullptr);
977
978 g_tcpDirectChannelInfoList = CreateSoftBusList();
979 ASSERT_TRUE(g_tcpDirectChannelInfoList != nullptr);
980
981 info->detail.fd = testFd;
982 (void)SoftBusMutexLock(&g_tcpDirectChannelInfoList->lock);
983 ListAdd(&g_tcpDirectChannelInfoList->list, &info->node);
984 (void)SoftBusMutexUnlock(&g_tcpDirectChannelInfoList->lock);
985
986 int32_t item = TransTdcGetInfoByFd(testFd, info);
987 EXPECT_EQ(item, SOFTBUS_OK);
988
989 SoftBusFree(info);
990 SoftBusFree(channel);
991 DestroySoftBusList(g_tcpDirectChannelInfoList);
992 g_tcpDirectChannelInfoList = nullptr;
993 }
994
995 /**
996 * @tc.name: TransTdcGetInfoByIdWithIncSeqTest001
997 * @tc.desc: TransTdcGetInfoIncFdRefById, use the wrong parameter.
998 * @tc.type: FUNC
999 * @tc.require:I5HQGA
1000 */
1001 HWTEST_F(TransSdkTcpDirectTest, TransTdcGetInfoByIdWithIncSeqTest001, TestSize.Level0)
1002 {
1003 int32_t channelId = 1;
1004 TcpDirectChannelInfo *info = (TcpDirectChannelInfo *)SoftBusCalloc(sizeof(TcpDirectChannelInfo));
1005 ASSERT_TRUE(info != nullptr);
1006
1007 ChannelInfo *channel = TestGetChannelInfo();
1008 ASSERT_TRUE(channel != nullptr);
1009
1010 g_tcpDirectChannelInfoList = CreateSoftBusList();
1011 ASSERT_TRUE(g_tcpDirectChannelInfoList != nullptr);
1012
1013 info->channelId = channelId;
1014 (void)SoftBusMutexLock(&g_tcpDirectChannelInfoList->lock);
1015 ListAdd(&g_tcpDirectChannelInfoList->list, &info->node);
1016 (void)SoftBusMutexUnlock(&g_tcpDirectChannelInfoList->lock);
1017
1018 TcpDirectChannelInfo *item = TransTdcGetInfoIncFdRefById(channelId, info, true);
1019 EXPECT_TRUE(item != nullptr);
1020
1021 SoftBusFree(info);
1022 SoftBusFree(channel);
1023 DestroySoftBusList(g_tcpDirectChannelInfoList);
1024 g_tcpDirectChannelInfoList = nullptr;
1025 }
1026 } // namespace OHOS
1027