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
35 using namespace testing::ext;
36
37 namespace OHOS {
38 #define INVALID_VALUE (-1)
39 #define SESSIONKEY_LEN 46
40 #define SESSION_KEY_LEN 46
41 static const char *g_sessionName = "ohos.distributedschedule.dms.test";
42 char g_peerSessionName[SESSIONKEY_LEN] = "ohos.distributedschedule.dms.test";
43 static const char *g_sessionkey = "clientkey";
44 char g_peerSessionKey[SESSION_KEY_LEN] = "clientkey";
45 static const char *g_pkgName = "pkgname";
46 static int32_t g_fd = socket(AF_INET, SOCK_STREAM, 0);
47
48 class TransSdkTcpDirectTest : public testing::Test {
49 public:
TransSdkTcpDirectTest()50 TransSdkTcpDirectTest()
51 {
52 }
~TransSdkTcpDirectTest()53 ~TransSdkTcpDirectTest()
54 {
55 }
56 static void SetUpTestCase(void);
57 static void TearDownTestCase(void);
SetUp()58 void SetUp() override
59 {
60 }
TearDown()61 void TearDown() override
62 {
63 }
64 };
65
OnServerSessionOpened(int sessionId,int result)66 static int OnServerSessionOpened(int sessionId, int result)
67 {
68 LOG_INFO("session opened,sesison id = %d\r\n", sessionId);
69 return SOFTBUS_OK;
70 }
71
OnServerSessionClosed(int sessionId)72 static void OnServerSessionClosed(int sessionId)
73 {
74 LOG_INFO("session closed, session id = %d\r\n", sessionId);
75 }
76
OnServerBytesReceived(int sessionId,const void * data,unsigned int len)77 static void OnServerBytesReceived(int sessionId, const void *data, unsigned int len)
78 {
79 LOG_INFO("session bytes received, session id = %d\r\n", sessionId);
80 }
81
OnServerMessageReceived(int sessionId,const void * data,unsigned int len)82 static void OnServerMessageReceived(int sessionId, const void *data, unsigned int len)
83 {
84 LOG_INFO("session msg received, session id = %d\r\n", sessionId);
85 }
86
87 static ISessionListener g_sessionlistener = {
88 .OnSessionOpened = OnServerSessionOpened,
89 .OnSessionClosed = OnServerSessionClosed,
90 .OnBytesReceived = OnServerBytesReceived,
91 .OnMessageReceived = OnServerMessageReceived,
92 };
93
SetUpTestCase(void)94 void TransSdkTcpDirectTest::SetUpTestCase(void)
95 {
96 int32_t ret = TransClientInit();
97 EXPECT_TRUE(ret == SOFTBUS_OK);
98 ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
99 EXPECT_EQ(ret, SOFTBUS_OK);
100 }
101
TearDownTestCase(void)102 void TransSdkTcpDirectTest::TearDownTestCase(void)
103 {
104 }
105
OnSessionOpened(const char * sessionName,const ChannelInfo * channel,SessionType flag)106 static int32_t OnSessionOpened(const char *sessionName, const ChannelInfo *channel, SessionType flag)
107 {
108 LOG_INFO("session opened,sesison id = %s\r\n", sessionName);
109 return SOFTBUS_OK;
110 }
111
OnSessionClosed(int32_t channelId,int32_t channelType)112 static int32_t OnSessionClosed(int32_t channelId, int32_t channelType)
113 {
114 LOG_INFO("session closed, session id = %d\r\n", channelId);
115 return SOFTBUS_OK;
116 }
117
OnSessionOpenFailed(int32_t channelId,int32_t channelType,int32_t errCode)118 static int32_t OnSessionOpenFailed(int32_t channelId, int32_t channelType, int32_t errCode)
119 {
120 LOG_INFO("session bytes received, session id = %d\r\n", channelId);
121 return SOFTBUS_OK;
122 }
123
OnDataReceived(int32_t channelId,int32_t channelType,const void * data,uint32_t len,SessionPktType type)124 static int32_t OnDataReceived(int32_t channelId, int32_t channelType,
125 const void *data, uint32_t len, SessionPktType type)
126 {
127 LOG_INFO("session msg received, session id = %d\r\n", channelId);
128 return SOFTBUS_OK;
129 }
130 static IClientSessionCallBack g_sessionCb = {
131 .OnSessionOpened = OnSessionOpened,
132 .OnSessionClosed = OnSessionClosed,
133 .OnSessionOpenFailed = OnSessionOpenFailed,
134 .OnDataReceived = OnDataReceived,
135 };
136
TestGetChannelInfo()137 ChannelInfo *TestGetChannelInfo()
138 {
139 ChannelInfo *info = (ChannelInfo *)SoftBusMalloc(sizeof(ChannelInfo));
140 (void)memset_s(info, sizeof(ChannelInfo), 0, sizeof(ChannelInfo));
141 info->peerSessionName = g_peerSessionName;
142 info->channelId = 1;
143 info->channelType = CHANNEL_TYPE_TCP_DIRECT;
144 info->sessionKey = g_peerSessionKey;
145 info->fd = g_fd;
146 return info;
147 }
148
TestGetTcpDirectChannelInfo()149 TcpDirectChannelInfo *TestGetTcpDirectChannelInfo()
150 {
151 TcpDirectChannelInfo *item = (TcpDirectChannelInfo *)SoftBusMalloc(sizeof(TcpDirectChannelInfo));
152 (void)memset_s(item, sizeof(TcpDirectChannelInfo), 0, sizeof(TcpDirectChannelInfo));
153 item->channelId = 1;
154 (void)memcpy_s(item->detail.sessionKey, SESSIONKEY_LEN, g_sessionkey, strlen(g_sessionkey));
155 item->detail.channelType = CHANNEL_TYPE_TCP_DIRECT;
156 item->detail.fd = g_fd;
157 return item;
158 }
159
160 /**
161 * @tc.name: ClientTransTdcOnChannelOpenedTest001
162 * @tc.desc: ClientTransTdcOnChannelOpened, use the wrong parameter.
163 * @tc.type: FUNC
164 * @tc.require:I5HQGA
165 */
166 HWTEST_F(TransSdkTcpDirectTest, ClientTransTdcOnChannelOpenedTest001, TestSize.Level0)
167 {
168 int32_t ret = TransTdcManagerInit(&g_sessionCb);
169 ASSERT_EQ(ret, SOFTBUS_OK);
170 ChannelInfo *channel = TestGetChannelInfo();
171 ASSERT_TRUE(channel != nullptr);
172 ret = ClientTransTdcOnChannelOpened(nullptr, channel);
173 EXPECT_TRUE(ret != SOFTBUS_OK);
174
175 ret = ClientTransTdcOnChannelOpened(g_sessionName, nullptr);
176 EXPECT_TRUE(ret != SOFTBUS_OK);
177
178 ret = ClientTransTdcOnChannelOpened(g_sessionName, channel);
179 EXPECT_TRUE(ret == SOFTBUS_OK);
180 TransTdcManagerDeinit();
181 SoftBusFree(channel);
182 }
183
184 /**
185 * @tc.name: TransTdcCloseChannelTest002
186 * @tc.desc: TransTdcCloseChannel, use the wrong parameter.
187 * @tc.type: FUNC
188 * @tc.require:I5HQGA
189 */
190 HWTEST_F(TransSdkTcpDirectTest, TransTdcCloseChannelTest002, TestSize.Level0)
191 {
192 int32_t channelId = 1;
193 ChannelInfo *channel = TestGetChannelInfo();
194 ASSERT_TRUE(channel != nullptr);
195 int32_t ret = TransTdcManagerInit(&g_sessionCb);
196 ASSERT_EQ(ret, SOFTBUS_OK);
197
198 TransTdcCloseChannel(channelId);
199
200 ret = ClientTransTdcOnChannelOpened(g_sessionName, channel);
201 EXPECT_TRUE(ret == SOFTBUS_OK);
202
203 TransTdcCloseChannel(channelId);
204
205 channelId = INVALID_VALUE;
206 TransTdcCloseChannel(channelId);
207 TransTdcManagerDeinit();
208 SoftBusFree(channel);
209 }
210
211 /**
212 * @tc.name: TransTdcGetSessionKeyTest003
213 * @tc.desc: TransTdcGetSessionKey, use the wrong parameter.
214 * @tc.type: FUNC
215 * @tc.require:I5HQGA
216 */
217 HWTEST_F(TransSdkTcpDirectTest, TransTdcGetSessionKeyTest003, TestSize.Level0)
218 {
219 int32_t channelId = 1;
220 unsigned int len = 32;
221 ChannelInfo *channel = TestGetChannelInfo();
222 ASSERT_TRUE(channel != nullptr);
223 int32_t ret = TransTdcManagerInit(&g_sessionCb);
224 ASSERT_EQ(ret, SOFTBUS_OK);
225
226 ret = ClientTransTdcOnChannelOpened(g_sessionName, channel);
227 EXPECT_TRUE(ret != SOFTBUS_OK);
228
229 ret = TransTdcGetSessionKey(channelId, nullptr, len);
230 EXPECT_TRUE(ret != SOFTBUS_OK);
231
232 ret = TransTdcGetSessionKey(channelId, const_cast<char *>(g_sessionkey), len);
233 EXPECT_TRUE(ret != SOFTBUS_OK);
234
235 channelId = INVALID_VALUE;
236 ret = TransTdcGetSessionKey(channelId, const_cast<char *>(g_sessionkey), len);
237 EXPECT_TRUE(ret != SOFTBUS_OK);
238 TransTdcManagerDeinit();
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.Level0)
249 {
250 int32_t channelId = 1;
251 int handle = 0;
252 ChannelInfo *channel = TestGetChannelInfo();
253 ASSERT_TRUE(channel != nullptr);
254 int32_t ret = TransTdcManagerInit(&g_sessionCb);
255 ASSERT_EQ(ret, SOFTBUS_OK);
256
257 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 TransTdcManagerDeinit();
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 int32_t ret = TransTdcManagerInit(&g_sessionCb);
284 ASSERT_EQ(ret, SOFTBUS_OK);
285
286 ChannelInfo *info = (ChannelInfo *)SoftBusCalloc(sizeof(ChannelInfo));
287 ASSERT_TRUE(info != nullptr);
288 (void)memset_s(info, sizeof(ChannelInfo), 0, sizeof(ChannelInfo));
289 info->peerSessionName = const_cast<char *>(g_sessionName);
290 info->channelId = 1;
291 info->channelType = CHANNEL_TYPE_TCP_DIRECT;
292 info->sessionKey = const_cast<char *>(g_sessionkey);
293 info->fd = INVALID_VALUE;
294
295 ret = ClientTransTdcOnChannelOpened(g_sessionName, info);
296 EXPECT_TRUE(ret != SOFTBUS_OK);
297
298 info->fd = g_fd;
299 ret = TransDisableSessionListener(channelId);
300 EXPECT_TRUE(ret != SOFTBUS_OK);
301
302 ret = TransDisableSessionListener(channelId);
303 EXPECT_TRUE(ret != SOFTBUS_OK);
304
305 channelId = INVALID_VALUE;
306 ret = TransDisableSessionListener(channelId);
307 EXPECT_TRUE(ret != SOFTBUS_OK);
308
309 TransTdcManagerDeinit();
310 SoftBusFree(info);
311 }
312
313 /**
314 * @tc.name: TransTdcGetInfoByIdTest006
315 * @tc.desc: TransTdcGetInfoById, use the wrong parameter.
316 * @tc.type: FUNC
317 * @tc.require:I5HQGA
318 */
319 HWTEST_F(TransSdkTcpDirectTest, TransTdcGetInfoByIdTest006, TestSize.Level0)
320 {
321 int32_t channelId = 1;
322 TcpDirectChannelInfo *info = (TcpDirectChannelInfo *)SoftBusMalloc(sizeof(TcpDirectChannelInfo));
323 ASSERT_TRUE(info != nullptr);
324 (void)memset_s(info, sizeof(TcpDirectChannelInfo), 0, sizeof(TcpDirectChannelInfo));
325
326 int32_t ret = TransTdcManagerInit(&g_sessionCb);
327 ASSERT_EQ(ret, SOFTBUS_OK);
328 ChannelInfo *channel = TestGetChannelInfo();
329 ASSERT_TRUE(channel != nullptr);
330 ret = ClientTransTdcOnChannelOpened(g_sessionName, channel);
331 EXPECT_TRUE(ret != SOFTBUS_OK);
332
333 TcpDirectChannelInfo *item = TransTdcGetInfoById(channelId, nullptr);
334 EXPECT_TRUE(item == nullptr);
335
336 item = TransTdcGetInfoById(channelId, info);
337 EXPECT_TRUE(item == nullptr);
338
339 channelId = INVALID_VALUE;
340 item = TransTdcGetInfoById(channelId, info);
341 EXPECT_TRUE(item == nullptr);
342 TransTdcManagerDeinit();
343 SoftBusFree(info);
344 SoftBusFree(channel);
345 }
346
347 /**
348 * @tc.name: TransTdcGetInfoByFdTest007
349 * @tc.desc: TransTdcGetInfoByFd, use the wrong parameter.
350 * @tc.type: FUNC
351 * @tc.require:I5HQGA
352 */
353 HWTEST_F(TransSdkTcpDirectTest, TransTdcGetInfoByFdTest007, TestSize.Level0)
354 {
355 int32_t fd = g_fd;
356 TcpDirectChannelInfo *info = (TcpDirectChannelInfo *)SoftBusMalloc(sizeof(TcpDirectChannelInfo));
357 ASSERT_TRUE(info != nullptr);
358 (void)memset_s(info, sizeof(TcpDirectChannelInfo), 0, sizeof(TcpDirectChannelInfo));
359
360 int32_t ret = TransTdcManagerInit(&g_sessionCb);
361 ASSERT_EQ(ret, SOFTBUS_OK);
362 ChannelInfo *channel = TestGetChannelInfo();
363 ASSERT_TRUE(channel != nullptr);
364 ret = ClientTransTdcOnChannelOpened(g_sessionName, channel);
365 EXPECT_TRUE(ret != SOFTBUS_OK);
366
367 TcpDirectChannelInfo *item = TransTdcGetInfoByFd(fd, nullptr);
368 EXPECT_TRUE(item == nullptr);
369
370 item = TransTdcGetInfoByFd(fd, info);
371 EXPECT_TRUE(item == nullptr);
372
373 fd = 1;
374 item = TransTdcGetInfoByFd(fd, info);
375 EXPECT_TRUE(item == nullptr);
376 TransTdcManagerDeinit();
377 SoftBusFree(info);
378 SoftBusFree(channel);
379 }
380
381 /**
382 * @tc.name: TransTdcGetInfoByIdWithIncSeqTest008
383 * @tc.desc: TransTdcGetInfoByIdWithIncSeq, use the wrong parameter.
384 * @tc.type: FUNC
385 * @tc.require:I5HQGA
386 */
387 HWTEST_F(TransSdkTcpDirectTest, TransTdcGetInfoByIdWithIncSeqTest008, TestSize.Level0)
388 {
389 int32_t channelId = 1;
390 TcpDirectChannelInfo *info = (TcpDirectChannelInfo *)SoftBusMalloc(sizeof(TcpDirectChannelInfo));
391 ASSERT_TRUE(info != nullptr);
392 (void)memset_s(info, sizeof(TcpDirectChannelInfo), 0, sizeof(TcpDirectChannelInfo));
393
394 int32_t ret = TransTdcManagerInit(&g_sessionCb);
395 ASSERT_EQ(ret, SOFTBUS_OK);
396 ChannelInfo *channel = TestGetChannelInfo();
397 ASSERT_TRUE(channel != nullptr);
398 ret = ClientTransTdcOnChannelOpened(g_sessionName, channel);
399 EXPECT_TRUE(ret != SOFTBUS_OK);
400
401 TcpDirectChannelInfo *item = TransTdcGetInfoByIdWithIncSeq(channelId, nullptr);
402 EXPECT_TRUE(item == nullptr);
403
404 item = TransTdcGetInfoByIdWithIncSeq(channelId, info);
405 EXPECT_TRUE(item == nullptr);
406
407 channelId = INVALID_VALUE;
408 item = TransTdcGetInfoByIdWithIncSeq(channelId, info);
409 EXPECT_TRUE(item == nullptr);
410 TransTdcManagerDeinit();
411 SoftBusFree(info);
412 SoftBusFree(channel);
413 }
414
415 /**
416 * @tc.name: ClientTransTdcSetCallBackTest009
417 * @tc.desc: ClientTransTdcSetCallBack, use the wrong parameter.
418 * @tc.type: FUNC
419 * @tc.require:I5HQGA
420 */
421 HWTEST_F(TransSdkTcpDirectTest, ClientTransTdcSetCallBackTest009, TestSize.Level0)
422 {
423 const IClientSessionCallBack *cb = GetClientSessionCb();
424 int32_t ret = ClientTransTdcSetCallBack(NULL);
425 EXPECT_TRUE(ret != SOFTBUS_OK);
426 ret = ClientTransTdcSetCallBack(cb);
427 EXPECT_TRUE(ret == SOFTBUS_OK);
428 }
429
430 /**
431 * @tc.name: ClientTransTdcOnSessionOpenedTest0010
432 * @tc.desc: ClientTransTdcOnSessionOpened, use the wrong parameter.
433 * @tc.type: FUNC
434 * @tc.require:I5HQGA
435 */
436 HWTEST_F(TransSdkTcpDirectTest, ClientTransTdcOnSessionOpenedTest0010, TestSize.Level0)
437 {
438 ChannelInfo *info = (ChannelInfo *)SoftBusCalloc(sizeof(ChannelInfo));
439 ASSERT_TRUE(info != nullptr);
440 (void)memset_s(info, sizeof(ChannelInfo), 0, sizeof(ChannelInfo));
441
442 int32_t ret = ClientTransTdcSetCallBack(&g_sessionCb);
443 ret = ClientTransTdcOnSessionOpened(g_sessionName, nullptr);
444 EXPECT_TRUE(ret == SOFTBUS_OK);
445
446 info->isServer = true;
447 info->channelType = CHANNEL_TYPE_AUTH;
448 ret = ClientTransTdcOnSessionOpened(nullptr, info);
449 EXPECT_TRUE(ret == SOFTBUS_OK);
450
451 ret = ClientTransTdcOnSessionOpened(g_sessionName, info);
452 EXPECT_TRUE(ret == SOFTBUS_OK);
453
454 info->isServer = false;
455 info->channelType = CHANNEL_TYPE_UDP;
456 ret = ClientTransTdcOnSessionOpened(g_sessionName, info);
457 EXPECT_TRUE(ret == SOFTBUS_OK);
458 SoftBusFree(info);
459 }
460
461 /**
462 * @tc.name: ClientTransTdcOnSessionClosedTest0011
463 * @tc.desc: ClientTransTdcOnSessionClosed, use the wrong parameter.
464 * @tc.type: FUNC
465 * @tc.require:I5HQGA
466 */
467 HWTEST_F(TransSdkTcpDirectTest, ClientTransTdcOnSessionClosedTest0011, TestSize.Level0)
468 {
469 int32_t channelId = 1;
470 int32_t errCode = SOFTBUS_OK;
471 int32_t ret = ClientTransTdcSetCallBack(&g_sessionCb);
472 ret = ClientTransTdcOnSessionClosed(channelId);
473 EXPECT_TRUE(ret == SOFTBUS_OK);
474
475 ret = ClientTransTdcOnSessionOpenFailed(channelId, errCode);
476 EXPECT_TRUE(ret == SOFTBUS_OK);
477
478 const char *data = "client";
479 uint32_t len = strlen(data);
480 ret = ClientTransTdcOnDataReceived(channelId, (void *)data, len, TRANS_SESSION_FILE_ONLYONE_FRAME);
481 EXPECT_TRUE(ret == SOFTBUS_OK);
482 }
483
484 /**
485 * @tc.name: TransTdcCreateListenerTest0012
486 * @tc.desc: TransTdcCreateListener, use the wrong parameter.
487 * @tc.type: FUNC
488 * @tc.require:I5HQGA
489 */
490 HWTEST_F(TransSdkTcpDirectTest, TransTdcCreateListenerTest0012, TestSize.Level0)
491 {
492 IClientSessionCallBack *cb = GetClientSessionCb();
493 int32_t ret = TransTdcManagerInit(cb);
494 int32_t fd = INVALID_VALUE;
495 ASSERT_EQ(ret, SOFTBUS_OK);
496
497 ret = TransTdcCreateListener(fd);
498 EXPECT_TRUE(ret != SOFTBUS_OK);
499 fd = g_fd;
500 ret = TransTdcCreateListener(fd);
501 EXPECT_TRUE(ret == SOFTBUS_OK);
502 TransTdcManagerDeinit();
503 }
504
505 /**
506 * @tc.name: TransTdcReleaseFdTest0013
507 * @tc.desc: TransTdcReleaseFd, use the wrong parameter.
508 * @tc.type: FUNC
509 * @tc.require:I5HQGA
510 */
511 HWTEST_F(TransSdkTcpDirectTest, TransTdcReleaseFdTest0013, TestSize.Level0)
512 {
513 int32_t fd = INVALID_VALUE;
514 IClientSessionCallBack *cb = GetClientSessionCb();
515 int32_t ret = TransTdcManagerInit(cb);
516 ASSERT_EQ(ret, SOFTBUS_OK);
517 TransTdcReleaseFd(fd);
518
519 fd = g_fd;
520 TransTdcReleaseFd(fd);
521 TransTdcManagerDeinit();
522 }
523
524 /**
525 * @tc.name: TransTdcStopReadTest0014
526 * @tc.desc: TransTdcStopRead, use the wrong parameter.
527 * @tc.type: FUNC
528 * @tc.require:I5HQGA
529 */
530 HWTEST_F(TransSdkTcpDirectTest, TransTdcStopReadTest0014, TestSize.Level0)
531 {
532 int32_t fd = INVALID_VALUE;
533 int32_t ret = TransTdcStopRead(fd);
534 EXPECT_TRUE(ret == SOFTBUS_OK);
535 fd = g_fd;
536 ret = TransTdcStopRead(fd);
537 EXPECT_TRUE(ret == SOFTBUS_OK);
538 }
539
540 /**
541 * @tc.name: ClientTransTdcOnChannelOpenFailedTest0015
542 * @tc.desc: ClientTransTdcOnChannelOpenFailed, use the wrong parameter.
543 * @tc.type: FUNC
544 * @tc.require:I5HQGA
545 */
546 HWTEST_F(TransSdkTcpDirectTest, ClientTransTdcOnChannelOpenFailedTest0015, TestSize.Level0)
547 {
548 int32_t ret = TransTdcManagerInit(&g_sessionCb);
549 ASSERT_EQ(ret, SOFTBUS_OK);
550 int32_t channelId = 1;
551 int32_t errCode = SOFTBUS_OK;
552 ret = ClientTransTdcOnChannelOpenFailed(channelId, errCode);
553 EXPECT_TRUE(ret == SOFTBUS_OK);
554
555 channelId = INVALID_VALUE;
556 ret = ClientTransTdcOnChannelOpenFailed(channelId, errCode);
557 EXPECT_TRUE(ret == SOFTBUS_OK);
558 TransTdcManagerDeinit();
559 }
560
561 /**
562 * @tc.name: TransDataListInitTest0016
563 * @tc.desc: TransDataListInit, use the wrong parameter.
564 * @tc.type: FUNC
565 * @tc.require:I5HQGA
566 */
567 HWTEST_F(TransSdkTcpDirectTest, TransDataListInitTest0016, TestSize.Level0)
568 {
569 int32_t channelId = 1;
570 int32_t fd = 1;
571 int32_t ret = TransAddDataBufNode(channelId, fd);
572 EXPECT_TRUE(ret != SOFTBUS_OK);
573
574 ret = TransDelDataBufNode(channelId);
575 EXPECT_TRUE(ret != SOFTBUS_OK);
576
577 ret = TransDataListInit();
578 ASSERT_EQ(ret, SOFTBUS_OK);
579
580 ret = TransAddDataBufNode(channelId, fd);
581 ASSERT_EQ(ret, SOFTBUS_OK);
582
583 ret = TransDelDataBufNode(channelId);
584 EXPECT_TRUE(ret == SOFTBUS_OK);
585
586 TransDataListDeinit();
587 }
588
589 /**
590 * @tc.name: TransTdcSendBytesTest0017
591 * @tc.desc: TransTdcSendBytes, use the wrong parameter.
592 * @tc.type: FUNC
593 * @tc.require:I5HQGA
594 */
595 HWTEST_F(TransSdkTcpDirectTest, TransTdcSendBytesTest0017, TestSize.Level0)
596 {
597 int32_t channelId = 1;
598 const char *data = "data";
599 uint32_t len = (uint32_t)strlen(data);
600 int32_t ret = TransTdcSendBytes(channelId, nullptr, len);
601 EXPECT_TRUE(ret != SOFTBUS_OK);
602
603 ret = TransTdcSendBytes(channelId, data, 0);
604 EXPECT_TRUE(ret != SOFTBUS_OK);
605
606 ret = TransTdcSendBytes(channelId, data, len);
607 EXPECT_TRUE(ret != SOFTBUS_OK);
608
609 ret = TransTdcManagerInit(&g_sessionCb);
610 ASSERT_EQ(ret, SOFTBUS_OK);
611 ChannelInfo *channel = TestGetChannelInfo();
612 ASSERT_TRUE(channel != nullptr);
613 ret = ClientTransTdcOnChannelOpened(g_sessionName, channel);
614 EXPECT_TRUE(ret != SOFTBUS_OK);
615
616 ret = TransTdcSendBytes(channelId, data, len);
617 EXPECT_TRUE(ret != SOFTBUS_OK);
618
619 TransTdcManagerDeinit();
620 SoftBusFree(channel);
621 }
622
623 /**
624 * @tc.name: TransTdcSendMessageTest0018
625 * @tc.desc: TransTdcSendMessage, use the wrong parameter.
626 * @tc.type: FUNC
627 * @tc.require:I5HQGA
628 */
629 HWTEST_F(TransSdkTcpDirectTest, TransTdcSendMessageTest0018, TestSize.Level0)
630 {
631 int32_t channelId = 1;
632 const char *data = "data";
633 uint32_t len = (uint32_t)strlen(data);
634 int32_t ret = TransTdcSendMessage(channelId, nullptr, len);
635 EXPECT_TRUE(ret != SOFTBUS_OK);
636
637 ret = TransTdcSendMessage(channelId, data, 0);
638 EXPECT_TRUE(ret != SOFTBUS_OK);
639
640 ret = TransTdcSendMessage(channelId, data, len);
641 EXPECT_TRUE(ret != SOFTBUS_OK);
642
643 ret = TransTdcManagerInit(&g_sessionCb);
644 ASSERT_EQ(ret, SOFTBUS_OK);
645 ChannelInfo *channel = TestGetChannelInfo();
646 ASSERT_TRUE(channel != nullptr);
647 ret = ClientTransTdcOnChannelOpened(g_sessionName, channel);
648 EXPECT_TRUE(ret != SOFTBUS_OK);
649
650 ret = TransTdcSendMessage(channelId, data, len);
651 EXPECT_TRUE(ret != SOFTBUS_OK);
652
653 TransTdcManagerDeinit();
654 SoftBusFree(channel);
655 }
656
657 /**
658 * @tc.name: TransTdcRecvDataTest0019
659 * @tc.desc: TransTdcRecvData, use the wrong parameter.
660 * @tc.type: FUNC
661 * @tc.require:I5HQGA
662 */
663 HWTEST_F(TransSdkTcpDirectTest, TransTdcRecvDataTest0019, TestSize.Level0)
664 {
665 int32_t channelId = 1;
666 int32_t fd = 1;
667 int32_t ret = TransTdcRecvData(channelId);
668 EXPECT_TRUE(ret != SOFTBUS_OK);
669
670 ret = TransDataListInit();
671 ASSERT_EQ(ret, SOFTBUS_OK);
672
673 ret = TransTdcRecvData(channelId);
674 EXPECT_TRUE(ret != SOFTBUS_OK);
675
676 ret = TransAddDataBufNode(channelId, fd);
677 ASSERT_EQ(ret, SOFTBUS_OK);
678
679 ret = TransTdcRecvData(channelId);
680 EXPECT_TRUE(ret != SOFTBUS_OK);
681 TransDataListDeinit();
682 }
683 }