1 /*
2 * Copyright (c) 2022 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.h"
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_tcp_direct_listener.h"
26 #include "session.h"
27 #include "softbus_def.h"
28 #include "softbus_errcode.h"
29 #include "softbus_adapter_mem.h"
30 #include "softbus_feature_config.h"
31 #include "softbus_log.h"
32 #include "softbus_access_token_test.h"
33 #include "trans_server_proxy.h"
34 #include "softbus_base_listener.h"
35
36 using namespace testing::ext;
37
38 namespace OHOS {
39 #define INVALID_VALUE (-1)
40 #define SESSIONKEY_LEN 46
41 #define SESSION_KEY_LEN 46
42 static const char *g_sessionName = "ohos.distributedschedule.dms.test";
43 char g_peerSessionName[SESSIONKEY_LEN] = "ohos.distributedschedule.dms.test";
44 static const char *g_sessionkey = "clientkey";
45 char g_peerSessionKey[SESSION_KEY_LEN] = "clientkey";
46 static const char *g_pkgName = "pkgname";
47 static int32_t g_fd = socket(AF_INET, SOCK_STREAM, 0);
48
49 class TransSdkTcpDirectTest : public testing::Test {
50 public:
TransSdkTcpDirectTest()51 TransSdkTcpDirectTest()
52 {
53 }
~TransSdkTcpDirectTest()54 ~TransSdkTcpDirectTest()
55 {
56 }
57 static void SetUpTestCase(void);
58 static void TearDownTestCase(void);
SetUp()59 void SetUp() override
60 {
61 }
TearDown()62 void TearDown() override
63 {
64 }
65 };
66
OnServerSessionOpened(int sessionId,int result)67 static int OnServerSessionOpened(int sessionId, int result)
68 {
69 LOG_INFO("session opened,sesison id = %d\r\n", sessionId);
70 return SOFTBUS_OK;
71 }
72
OnServerSessionClosed(int sessionId)73 static void OnServerSessionClosed(int sessionId)
74 {
75 LOG_INFO("session closed, session id = %d\r\n", sessionId);
76 }
77
OnServerBytesReceived(int sessionId,const void * data,unsigned int len)78 static void OnServerBytesReceived(int sessionId, const void *data, unsigned int len)
79 {
80 LOG_INFO("session bytes received, session id = %d\r\n", sessionId);
81 }
82
OnServerMessageReceived(int sessionId,const void * data,unsigned int len)83 static void OnServerMessageReceived(int sessionId, const void *data, unsigned int len)
84 {
85 LOG_INFO("session msg received, session id = %d\r\n", sessionId);
86 }
87
88 static ISessionListener g_sessionlistener = {
89 .OnSessionOpened = OnServerSessionOpened,
90 .OnSessionClosed = OnServerSessionClosed,
91 .OnBytesReceived = OnServerBytesReceived,
92 .OnMessageReceived = OnServerMessageReceived,
93 };
94
95
OnSessionOpened(const char * sessionName,const ChannelInfo * channel,SessionType flag)96 static int32_t OnSessionOpened(const char *sessionName, const ChannelInfo *channel, SessionType flag)
97 {
98 LOG_INFO("session opened,sesison id = %s\r\n", sessionName);
99 return SOFTBUS_OK;
100 }
101
OnSessionClosed(int32_t channelId,int32_t channelType)102 static int32_t OnSessionClosed(int32_t channelId, int32_t channelType)
103 {
104 LOG_INFO("session closed, session id = %d\r\n", channelId);
105 return SOFTBUS_OK;
106 }
107
OnSessionOpenFailed(int32_t channelId,int32_t channelType,int32_t errCode)108 static int32_t OnSessionOpenFailed(int32_t channelId, int32_t channelType, int32_t errCode)
109 {
110 LOG_INFO("session bytes received, session id = %d\r\n", channelId);
111 return SOFTBUS_OK;
112 }
113
OnDataReceived(int32_t channelId,int32_t channelType,const void * data,uint32_t len,SessionPktType type)114 static int32_t OnDataReceived(int32_t channelId, int32_t channelType,
115 const void *data, uint32_t len, SessionPktType type)
116 {
117 LOG_INFO("session msg received, session id = %d\r\n", channelId);
118 return SOFTBUS_OK;
119 }
120 static IClientSessionCallBack g_sessionCb = {
121 .OnSessionOpened = OnSessionOpened,
122 .OnSessionClosed = OnSessionClosed,
123 .OnSessionOpenFailed = OnSessionOpenFailed,
124 .OnDataReceived = OnDataReceived,
125 };
126
TestGetChannelInfo()127 ChannelInfo *TestGetChannelInfo()
128 {
129 ChannelInfo *info = (ChannelInfo *)SoftBusMalloc(sizeof(ChannelInfo));
130 (void)memset_s(info, sizeof(ChannelInfo), 0, sizeof(ChannelInfo));
131 info->peerSessionName = g_peerSessionName;
132 info->channelId = 1;
133 info->channelType = CHANNEL_TYPE_TCP_DIRECT;
134 info->sessionKey = g_peerSessionKey;
135 info->fd = g_fd;
136 return info;
137 }
138
TestGetTcpDirectChannelInfo()139 TcpDirectChannelInfo *TestGetTcpDirectChannelInfo()
140 {
141 TcpDirectChannelInfo *item = (TcpDirectChannelInfo *)SoftBusMalloc(sizeof(TcpDirectChannelInfo));
142 (void)memset_s(item, sizeof(TcpDirectChannelInfo), 0, sizeof(TcpDirectChannelInfo));
143 item->channelId = 1;
144 (void)memcpy_s(item->detail.sessionKey, SESSIONKEY_LEN, g_sessionkey, strlen(g_sessionkey));
145 item->detail.channelType = CHANNEL_TYPE_TCP_DIRECT;
146 item->detail.fd = g_fd;
147 return item;
148 }
149
SetUpTestCase(void)150 void TransSdkTcpDirectTest::SetUpTestCase(void)
151 {
152 int32_t ret = TransClientInit();
153 EXPECT_TRUE(ret == SOFTBUS_OK);
154 TransTdcManagerInit(&g_sessionCb);
155 ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
156 EXPECT_EQ(ret, SOFTBUS_OK);
157 ret = InitBaseListener();
158 EXPECT_TRUE(ret == SOFTBUS_OK);
159 }
160
TearDownTestCase(void)161 void TransSdkTcpDirectTest::TearDownTestCase(void)
162 {
163 TransTdcManagerDeinit();
164 }
165
166 /**
167 * @tc.name: ClientTransTdcOnChannelOpenedTest001
168 * @tc.desc: ClientTransTdcOnChannelOpened, use the wrong parameter.
169 * @tc.type: FUNC
170 * @tc.require:I5HQGA
171 */
172 HWTEST_F(TransSdkTcpDirectTest, ClientTransTdcOnChannelOpenedTest001, TestSize.Level0)
173 {
174 ChannelInfo *channel = TestGetChannelInfo();
175 ASSERT_TRUE(channel != nullptr);
176 int32_t ret = ClientTransTdcOnChannelOpened(nullptr, channel);
177 EXPECT_TRUE(ret != SOFTBUS_OK);
178
179 ret = ClientTransTdcOnChannelOpened(g_sessionName, nullptr);
180 EXPECT_TRUE(ret != SOFTBUS_OK);
181
182 ret = ClientTransTdcOnChannelOpened(g_sessionName, channel);
183 EXPECT_TRUE(ret == SOFTBUS_OK);
184
185 SoftBusFree(channel);
186 }
187
188 /**
189 * @tc.name: TransTdcCloseChannelTest002
190 * @tc.desc: TransTdcCloseChannel, use the wrong parameter.
191 * @tc.type: FUNC
192 * @tc.require:I5HQGA
193 */
194 HWTEST_F(TransSdkTcpDirectTest, TransTdcCloseChannelTest002, TestSize.Level0)
195 {
196 int32_t channelId = 1;
197 ChannelInfo *channel = TestGetChannelInfo();
198 ASSERT_TRUE(channel != nullptr);
199
200 TransTdcManagerInit(&g_sessionCb);
201
202 TransTdcCloseChannel(channelId);
203
204 int32_t ret = ClientTransTdcOnChannelOpened(g_sessionName, channel);
205 EXPECT_TRUE(ret == SOFTBUS_OK);
206
207 TransTdcCloseChannel(channelId);
208
209 channelId = INVALID_VALUE;
210 TransTdcCloseChannel(channelId);
211
212 SoftBusFree(channel);
213 }
214
215 /**
216 * @tc.name: TransTdcGetSessionKeyTest003
217 * @tc.desc: TransTdcGetSessionKey, use the wrong parameter.
218 * @tc.type: FUNC
219 * @tc.require:I5HQGA
220 */
221 HWTEST_F(TransSdkTcpDirectTest, TransTdcGetSessionKeyTest003, TestSize.Level0)
222 {
223 int32_t channelId = 1;
224 unsigned int len = 32;
225 ChannelInfo *channel = TestGetChannelInfo();
226 ASSERT_TRUE(channel != nullptr);
227
228 int32_t ret = ClientTransTdcOnChannelOpened(g_sessionName, channel);
229 EXPECT_TRUE(ret != SOFTBUS_OK);
230
231 ret = TransTdcGetSessionKey(channelId, nullptr, len);
232 EXPECT_TRUE(ret != SOFTBUS_OK);
233
234 ret = TransTdcGetSessionKey(channelId, const_cast<char *>(g_sessionkey), len);
235 EXPECT_TRUE(ret != SOFTBUS_OK);
236
237 channelId = INVALID_VALUE;
238 ret = TransTdcGetSessionKey(channelId, const_cast<char *>(g_sessionkey), len);
239 EXPECT_TRUE(ret != SOFTBUS_OK);
240
241 SoftBusFree(channel);
242 }
243
244 /**
245 * @tc.name: TransTdcGetHandleTest004
246 * @tc.desc: TransTdcGetHandle, use the wrong parameter.
247 * @tc.type: FUNC
248 * @tc.require:I5HQGA
249 */
250 HWTEST_F(TransSdkTcpDirectTest, TransTdcGetHandleTest004, TestSize.Level0)
251 {
252 int32_t channelId = 1;
253 int handle = 0;
254 ChannelInfo *channel = TestGetChannelInfo();
255 ASSERT_TRUE(channel != nullptr);
256
257 int32_t ret = ClientTransTdcOnChannelOpened(g_sessionName, channel);
258 EXPECT_TRUE(ret != SOFTBUS_OK);
259
260 ret = TransTdcGetHandle(channelId, nullptr);
261 EXPECT_TRUE(ret != SOFTBUS_OK);
262
263 ret = TransTdcGetHandle(channelId, &handle);
264 EXPECT_TRUE(ret != SOFTBUS_OK);
265
266 channelId = INVALID_VALUE;
267 ret = TransTdcGetHandle(channelId, &handle);
268 EXPECT_TRUE(ret != SOFTBUS_OK);
269
270 SoftBusFree(channel);
271 }
272
273 /**
274 * @tc.name: TransDisableSessionListenerTest005
275 * @tc.desc: TransDisableSessionListener, use the wrong parameter.
276 * @tc.type: FUNC
277 * @tc.require:I5HQGA
278 */
279
280 HWTEST_F(TransSdkTcpDirectTest, TransDisableSessionListenerTest005, TestSize.Level0)
281 {
282 int32_t channelId = 1;
283
284 ChannelInfo *info = (ChannelInfo *)SoftBusCalloc(sizeof(ChannelInfo));
285 ASSERT_TRUE(info != nullptr);
286 (void)memset_s(info, sizeof(ChannelInfo), 0, sizeof(ChannelInfo));
287 info->peerSessionName = const_cast<char *>(g_sessionName);
288 info->channelId = 1;
289 info->channelType = CHANNEL_TYPE_TCP_DIRECT;
290 info->sessionKey = const_cast<char *>(g_sessionkey);
291 info->fd = INVALID_VALUE;
292
293 int32_t ret = ClientTransTdcOnChannelOpened(g_sessionName, info);
294 EXPECT_TRUE(ret != SOFTBUS_OK);
295
296 info->fd = g_fd;
297 ret = TransDisableSessionListener(channelId);
298 EXPECT_TRUE(ret != SOFTBUS_OK);
299
300 ret = TransDisableSessionListener(channelId);
301 EXPECT_TRUE(ret != SOFTBUS_OK);
302
303 channelId = INVALID_VALUE;
304 ret = TransDisableSessionListener(channelId);
305 EXPECT_TRUE(ret != SOFTBUS_OK);
306
307 SoftBusFree(info);
308 }
309
310 /**
311 * @tc.name: TransTdcGetInfoByIdTest006
312 * @tc.desc: TransTdcGetInfoById, use the wrong parameter.
313 * @tc.type: FUNC
314 * @tc.require:I5HQGA
315 */
316 HWTEST_F(TransSdkTcpDirectTest, TransTdcGetInfoByIdTest006, TestSize.Level0)
317 {
318 int32_t channelId = 1;
319 TcpDirectChannelInfo *info = (TcpDirectChannelInfo *)SoftBusMalloc(sizeof(TcpDirectChannelInfo));
320 ASSERT_TRUE(info != nullptr);
321 (void)memset_s(info, sizeof(TcpDirectChannelInfo), 0, sizeof(TcpDirectChannelInfo));
322
323 ChannelInfo *channel = TestGetChannelInfo();
324 ASSERT_TRUE(channel != nullptr);
325 int32_t ret = ClientTransTdcOnChannelOpened(g_sessionName, channel);
326 EXPECT_TRUE(ret != SOFTBUS_OK);
327
328 TcpDirectChannelInfo *item = TransTdcGetInfoById(channelId, nullptr);
329 EXPECT_TRUE(item == nullptr);
330
331 item = TransTdcGetInfoById(channelId, info);
332 EXPECT_TRUE(item == nullptr);
333
334 channelId = INVALID_VALUE;
335 item = TransTdcGetInfoById(channelId, info);
336 EXPECT_TRUE(item == nullptr);
337
338 SoftBusFree(info);
339 SoftBusFree(channel);
340 }
341
342 /**
343 * @tc.name: TransTdcGetInfoByFdTest007
344 * @tc.desc: TransTdcGetInfoByFd, use the wrong parameter.
345 * @tc.type: FUNC
346 * @tc.require:I5HQGA
347 */
348 HWTEST_F(TransSdkTcpDirectTest, TransTdcGetInfoByFdTest007, TestSize.Level0)
349 {
350 int32_t fd = g_fd;
351 TcpDirectChannelInfo *info = (TcpDirectChannelInfo *)SoftBusMalloc(sizeof(TcpDirectChannelInfo));
352 ASSERT_TRUE(info != nullptr);
353 (void)memset_s(info, sizeof(TcpDirectChannelInfo), 0, sizeof(TcpDirectChannelInfo));
354
355 ChannelInfo *channel = TestGetChannelInfo();
356 ASSERT_TRUE(channel != nullptr);
357 int32_t ret = ClientTransTdcOnChannelOpened(g_sessionName, channel);
358 EXPECT_TRUE(ret != SOFTBUS_OK);
359
360 TcpDirectChannelInfo *item = TransTdcGetInfoByFd(fd, nullptr);
361 EXPECT_TRUE(item == nullptr);
362
363 item = TransTdcGetInfoByFd(fd, info);
364 EXPECT_TRUE(item == nullptr);
365
366 fd = 1;
367 item = TransTdcGetInfoByFd(fd, info);
368 EXPECT_TRUE(item == nullptr);
369
370 SoftBusFree(info);
371 SoftBusFree(channel);
372 }
373
374 /**
375 * @tc.name: TransTdcGetInfoByIdWithIncSeqTest008
376 * @tc.desc: TransTdcGetInfoByIdWithIncSeq, use the wrong parameter.
377 * @tc.type: FUNC
378 * @tc.require:I5HQGA
379 */
380 HWTEST_F(TransSdkTcpDirectTest, TransTdcGetInfoByIdWithIncSeqTest008, TestSize.Level0)
381 {
382 int32_t channelId = 1;
383 TcpDirectChannelInfo *info = (TcpDirectChannelInfo *)SoftBusMalloc(sizeof(TcpDirectChannelInfo));
384 ASSERT_TRUE(info != nullptr);
385 (void)memset_s(info, sizeof(TcpDirectChannelInfo), 0, sizeof(TcpDirectChannelInfo));
386
387 ChannelInfo *channel = TestGetChannelInfo();
388 ASSERT_TRUE(channel != nullptr);
389 int32_t ret = ClientTransTdcOnChannelOpened(g_sessionName, channel);
390 EXPECT_TRUE(ret != SOFTBUS_OK);
391
392 TcpDirectChannelInfo *item = TransTdcGetInfoByIdWithIncSeq(channelId, nullptr);
393 EXPECT_TRUE(item == nullptr);
394
395 item = TransTdcGetInfoByIdWithIncSeq(channelId, info);
396 EXPECT_TRUE(item == nullptr);
397
398 channelId = INVALID_VALUE;
399 item = TransTdcGetInfoByIdWithIncSeq(channelId, info);
400 EXPECT_TRUE(item == nullptr);
401
402 SoftBusFree(info);
403 SoftBusFree(channel);
404 }
405
406 /**
407 * @tc.name: ClientTransTdcSetCallBackTest009
408 * @tc.desc: ClientTransTdcSetCallBack, use the wrong parameter.
409 * @tc.type: FUNC
410 * @tc.require:I5HQGA
411 */
412 HWTEST_F(TransSdkTcpDirectTest, ClientTransTdcSetCallBackTest009, TestSize.Level0)
413 {
414 const IClientSessionCallBack *cb = GetClientSessionCb();
415 int32_t ret = ClientTransTdcSetCallBack(NULL);
416 EXPECT_TRUE(ret != SOFTBUS_OK);
417 ret = ClientTransTdcSetCallBack(cb);
418 EXPECT_TRUE(ret == SOFTBUS_OK);
419 }
420
421 /**
422 * @tc.name: ClientTransTdcOnSessionOpenedTest0010
423 * @tc.desc: ClientTransTdcOnSessionOpened, use the wrong parameter.
424 * @tc.type: FUNC
425 * @tc.require:I5HQGA
426 */
427 HWTEST_F(TransSdkTcpDirectTest, ClientTransTdcOnSessionOpenedTest0010, TestSize.Level0)
428 {
429 ChannelInfo *info = (ChannelInfo *)SoftBusCalloc(sizeof(ChannelInfo));
430 ASSERT_TRUE(info != nullptr);
431 (void)memset_s(info, sizeof(ChannelInfo), 0, sizeof(ChannelInfo));
432
433 int32_t ret = ClientTransTdcSetCallBack(&g_sessionCb);
434 ret = ClientTransTdcOnSessionOpened(g_sessionName, nullptr);
435 EXPECT_TRUE(ret == SOFTBUS_OK);
436
437 info->isServer = true;
438 info->channelType = CHANNEL_TYPE_AUTH;
439 ret = ClientTransTdcOnSessionOpened(nullptr, info);
440 EXPECT_TRUE(ret == SOFTBUS_OK);
441
442 ret = ClientTransTdcOnSessionOpened(g_sessionName, info);
443 EXPECT_TRUE(ret == SOFTBUS_OK);
444
445 info->isServer = false;
446 info->channelType = CHANNEL_TYPE_UDP;
447 ret = ClientTransTdcOnSessionOpened(g_sessionName, info);
448 EXPECT_TRUE(ret == SOFTBUS_OK);
449 SoftBusFree(info);
450 }
451
452 /**
453 * @tc.name: ClientTransTdcOnSessionClosedTest0011
454 * @tc.desc: ClientTransTdcOnSessionClosed, use the wrong parameter.
455 * @tc.type: FUNC
456 * @tc.require:I5HQGA
457 */
458 HWTEST_F(TransSdkTcpDirectTest, ClientTransTdcOnSessionClosedTest0011, TestSize.Level0)
459 {
460 int32_t channelId = 1;
461 int32_t errCode = SOFTBUS_OK;
462 int32_t ret = ClientTransTdcSetCallBack(&g_sessionCb);
463 ret = ClientTransTdcOnSessionClosed(channelId);
464 EXPECT_TRUE(ret == SOFTBUS_OK);
465
466 ret = ClientTransTdcOnSessionOpenFailed(channelId, errCode);
467 EXPECT_TRUE(ret == SOFTBUS_OK);
468
469 const char *data = "client";
470 uint32_t len = strlen(data);
471 ret = ClientTransTdcOnDataReceived(channelId, (void *)data, len, TRANS_SESSION_FILE_ONLYONE_FRAME);
472 EXPECT_TRUE(ret == SOFTBUS_OK);
473 }
474
475 /**
476 * @tc.name: TransTdcCreateListenerTest0012
477 * @tc.desc: TransTdcCreateListener, use the wrong parameter.
478 * @tc.type: FUNC
479 * @tc.require:I5HQGA
480 */
481 HWTEST_F(TransSdkTcpDirectTest, TransTdcCreateListenerTest0012, TestSize.Level0)
482 {
483 int32_t fd = INVALID_VALUE;
484 int32_t ret = TransTdcCreateListener(fd);
485 EXPECT_TRUE(ret != SOFTBUS_OK);
486 fd = g_fd;
487 ret = TransTdcCreateListener(fd);
488 EXPECT_TRUE(ret == SOFTBUS_OK);
489 }
490
491 /**
492 * @tc.name: TransTdcReleaseFdTest0013
493 * @tc.desc: TransTdcReleaseFd, use the wrong parameter.
494 * @tc.type: FUNC
495 * @tc.require:I5HQGA
496 */
497 HWTEST_F(TransSdkTcpDirectTest, TransTdcReleaseFdTest0013, TestSize.Level0)
498 {
499 int32_t fd = INVALID_VALUE;
500 TransTdcReleaseFd(fd);
501 EXPECT_EQ(fd, INVALID_VALUE);
502
503 fd = g_fd;
504 TransTdcReleaseFd(fd);
505 EXPECT_TRUE(g_fd == fd);
506 }
507
508 /**
509 * @tc.name: TransTdcStopReadTest0014
510 * @tc.desc: TransTdcStopRead, use the wrong parameter.
511 * @tc.type: FUNC
512 * @tc.require:I5HQGA
513 */
514 HWTEST_F(TransSdkTcpDirectTest, TransTdcStopReadTest0014, TestSize.Level0)
515 {
516 int32_t fd = INVALID_VALUE;
517 int32_t ret = TransTdcStopRead(fd);
518 EXPECT_TRUE(ret == SOFTBUS_OK);
519 fd = g_fd;
520 ret = TransTdcStopRead(fd);
521 EXPECT_TRUE(ret == SOFTBUS_OK);
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_TRUE(ret == SOFTBUS_OK);
536
537 channelId = INVALID_VALUE;
538 ret = ClientTransTdcOnChannelOpenFailed(channelId, errCode);
539 EXPECT_TRUE(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_TRUE(ret != SOFTBUS_OK);
555
556 ret = TransDelDataBufNode(channelId);
557 EXPECT_TRUE(ret != SOFTBUS_OK);
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_TRUE(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);
583 EXPECT_TRUE(ret != SOFTBUS_OK);
584
585 ret = TransTdcSendBytes(channelId, data, 0);
586 EXPECT_TRUE(ret != SOFTBUS_OK);
587
588 ret = TransTdcSendBytes(channelId, data, len);
589 EXPECT_TRUE(ret != SOFTBUS_OK);
590
591 ChannelInfo *channel = TestGetChannelInfo();
592 ASSERT_TRUE(channel != nullptr);
593 ret = ClientTransTdcOnChannelOpened(g_sessionName, channel);
594 EXPECT_TRUE(ret != SOFTBUS_OK);
595
596 ret = TransTdcSendBytes(channelId, data, len);
597 EXPECT_TRUE(ret != SOFTBUS_OK);
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_TRUE(ret != SOFTBUS_OK);
615
616 ret = TransTdcSendMessage(channelId, data, 0);
617 EXPECT_TRUE(ret != SOFTBUS_OK);
618
619 ret = TransTdcSendMessage(channelId, data, len);
620 EXPECT_TRUE(ret != SOFTBUS_OK);
621
622 ChannelInfo *channel = TestGetChannelInfo();
623 ASSERT_TRUE(channel != nullptr);
624 ret = ClientTransTdcOnChannelOpened(g_sessionName, channel);
625 EXPECT_TRUE(ret != SOFTBUS_OK);
626
627 ret = TransTdcSendMessage(channelId, data, len);
628 EXPECT_TRUE(ret != SOFTBUS_OK);
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_TRUE(ret != SOFTBUS_OK);
645
646 ret = TransDataListInit();
647 ASSERT_EQ(ret, SOFTBUS_OK);
648
649 ret = TransTdcRecvData(channelId);
650 EXPECT_TRUE(ret != SOFTBUS_OK);
651
652 ret = TransAddDataBufNode(channelId, fd);
653 ASSERT_EQ(ret, SOFTBUS_OK);
654
655 ret = TransTdcRecvData(channelId);
656 EXPECT_TRUE(ret != SOFTBUS_OK);
657 TransDataListDeinit();
658 }
659 } // namespace OHOS
660