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.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_socket_manager.h"
26 #include "client_trans_tcp_direct_listener.h"
27 #include "session.h"
28 #include "softbus_def.h"
29 #include "softbus_errcode.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(int sessionId,int result)64 static int OnServerSessionOpened(int sessionId, int result)
65 {
66 TRANS_LOGI(TRANS_TEST, "session opened, sesisonId=%{public}d\r\n", sessionId);
67 return SOFTBUS_OK;
68 }
69
OnServerSessionClosed(int sessionId)70 static void OnServerSessionClosed(int sessionId)
71 {
72 TRANS_LOGI(TRANS_TEST, "session closed, sessionId=%{public}d\r\n", sessionId);
73 }
74
OnServerBytesReceived(int sessionId,const void * data,unsigned int len)75 static void OnServerBytesReceived(int 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(int sessionId,const void * data,unsigned int len)80 static void OnServerMessageReceived(int 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 int 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 TcpDirectChannelInfo *item = TransTdcGetInfoById(channelId, nullptr);
326 EXPECT_TRUE(item == nullptr);
327
328 item = TransTdcGetInfoById(channelId, info);
329 EXPECT_TRUE(item == nullptr);
330
331 channelId = INVALID_VALUE;
332 item = TransTdcGetInfoById(channelId, info);
333 EXPECT_TRUE(item == nullptr);
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 TcpDirectChannelInfo *item = TransTdcGetInfoByFd(fd, nullptr);
358 EXPECT_TRUE(item == nullptr);
359
360 item = TransTdcGetInfoByFd(fd, info);
361 EXPECT_TRUE(item == nullptr);
362
363 fd = 1;
364 item = TransTdcGetInfoByFd(fd, info);
365 EXPECT_TRUE(item == nullptr);
366
367 SoftBusFree(info);
368 SoftBusFree(channel);
369 }
370
371 /**
372 * @tc.name: TransTdcGetInfoByIdWithIncSeqTest008
373 * @tc.desc: TransTdcGetInfoByIdWithIncSeq, 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 = TransTdcGetInfoByIdWithIncSeq(channelId, nullptr);
390 EXPECT_TRUE(item == nullptr);
391
392 item = TransTdcGetInfoByIdWithIncSeq(channelId, info);
393 EXPECT_TRUE(item == nullptr);
394
395 channelId = INVALID_VALUE;
396 item = TransTdcGetInfoByIdWithIncSeq(channelId, info);
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(NULL);
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_OK);
433
434 info->isServer = true;
435 info->channelType = CHANNEL_TYPE_AUTH;
436 ret = ClientTransTdcOnSessionOpened(nullptr, info);
437 EXPECT_EQ(ret, SOFTBUS_OK);
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;
516 ret = TransTdcStopRead(fd);
517 EXPECT_EQ(ret, SOFTBUS_OK);
518 }
519
520 /**
521 * @tc.name: ClientTransTdcOnChannelOpenFailedTest0015
522 * @tc.desc: ClientTransTdcOnChannelOpenFailed, use the wrong parameter.
523 * @tc.type: FUNC
524 * @tc.require:I5HQGA
525 */
526 HWTEST_F(TransSdkTcpDirectTest, ClientTransTdcOnChannelOpenFailedTest0015, TestSize.Level0)
527 {
528 int32_t channelId = 1;
529 int32_t errCode = SOFTBUS_OK;
530 int32_t ret = ClientTransTdcOnChannelOpenFailed(channelId, errCode);
531 EXPECT_EQ(ret, SOFTBUS_OK);
532
533 channelId = INVALID_VALUE;
534 ret = ClientTransTdcOnChannelOpenFailed(channelId, errCode);
535 EXPECT_EQ(ret, SOFTBUS_OK);
536 }
537
538 /**
539 * @tc.name: TransDataListInitTest0016
540 * @tc.desc: TransDataListInit, use the wrong parameter.
541 * @tc.type: FUNC
542 * @tc.require:I5HQGA
543 */
544 HWTEST_F(TransSdkTcpDirectTest, TransDataListInitTest0016, TestSize.Level0)
545 {
546 int32_t channelId = 1;
547 int32_t fd = 1;
548 TransDataListDeinit();
549 int32_t ret = TransAddDataBufNode(channelId, fd);
550 EXPECT_EQ(ret, SOFTBUS_NO_INIT);
551
552 ret = TransDelDataBufNode(channelId);
553 EXPECT_EQ(ret, SOFTBUS_NO_INIT);
554
555 ret = TransDataListInit();
556 ASSERT_EQ(ret, SOFTBUS_OK);
557
558 ret = TransAddDataBufNode(channelId, fd);
559 ASSERT_EQ(ret, SOFTBUS_OK);
560
561 ret = TransDelDataBufNode(channelId);
562 EXPECT_EQ(ret, SOFTBUS_OK);
563
564 TransDataListDeinit();
565 }
566
567 /**
568 * @tc.name: TransTdcSendBytesTest0017
569 * @tc.desc: TransTdcSendBytes, use the wrong parameter.
570 * @tc.type: FUNC
571 * @tc.require:I5HQGA
572 */
573 HWTEST_F(TransSdkTcpDirectTest, TransTdcSendBytesTest0017, TestSize.Level0)
574 {
575 int32_t channelId = 1;
576 const char *data = "data";
577 uint32_t len = (uint32_t)strlen(data);
578 int32_t ret = TransTdcSendBytes(channelId, nullptr, len);
579 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
580
581 ret = TransTdcSendBytes(channelId, data, 0);
582 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
583
584 ret = TransTdcSendBytes(channelId, data, len);
585 EXPECT_EQ(ret, SOFTBUS_TRANS_TDC_GET_INFO_FAILED);
586
587 ChannelInfo *channel = TestGetChannelInfo();
588 ASSERT_TRUE(channel != nullptr);
589 ret = ClientTransTdcOnChannelOpened(g_sessionName, channel);
590 EXPECT_EQ(ret, SOFTBUS_MEM_ERR);
591
592 ret = TransTdcSendBytes(channelId, data, len);
593 EXPECT_EQ(ret, SOFTBUS_TRANS_TDC_GET_INFO_FAILED);
594
595 SoftBusFree(channel);
596 }
597
598 /**
599 * @tc.name: TransTdcSendMessageTest0018
600 * @tc.desc: TransTdcSendMessage, use the wrong parameter.
601 * @tc.type: FUNC
602 * @tc.require:I5HQGA
603 */
604 HWTEST_F(TransSdkTcpDirectTest, TransTdcSendMessageTest0018, TestSize.Level0)
605 {
606 int32_t channelId = 1;
607 const char *data = "data";
608 uint32_t len = (uint32_t)strlen(data);
609 int32_t ret = TransTdcSendMessage(channelId, nullptr, len);
610 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
611
612 ret = TransTdcSendMessage(channelId, data, 0);
613 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
614
615 ret = TransTdcSendMessage(channelId, data, len);
616 EXPECT_EQ(ret, SOFTBUS_TRANS_TDC_CHANNEL_NOT_FOUND);
617
618 ChannelInfo *channel = TestGetChannelInfo();
619 ASSERT_TRUE(channel != nullptr);
620 ret = ClientTransTdcOnChannelOpened(g_sessionName, channel);
621 EXPECT_EQ(ret, SOFTBUS_MEM_ERR);
622
623 ret = TransTdcSendMessage(channelId, data, len);
624 EXPECT_EQ(ret, SOFTBUS_TRANS_TDC_CHANNEL_NOT_FOUND);
625
626 SoftBusFree(channel);
627 }
628
629 /**
630 * @tc.name: TransTdcRecvDataTest0019
631 * @tc.desc: TransTdcRecvData, use the wrong parameter.
632 * @tc.type: FUNC
633 * @tc.require:I5HQGA
634 */
635 HWTEST_F(TransSdkTcpDirectTest, TransTdcRecvDataTest0019, TestSize.Level0)
636 {
637 int32_t channelId = 1;
638 int32_t fd = 1;
639 int32_t ret = TransTdcRecvData(channelId);
640 EXPECT_EQ(ret, SOFTBUS_NO_INIT);
641
642 ret = TransDataListInit();
643 ASSERT_EQ(ret, SOFTBUS_OK);
644
645 ret = TransTdcRecvData(channelId);
646 EXPECT_EQ(ret, SOFTBUS_TRANS_TDC_CHANNEL_NOT_FOUND);
647
648 ret = TransAddDataBufNode(channelId, fd);
649 ASSERT_EQ(ret, SOFTBUS_OK);
650
651 ret = TransTdcRecvData(channelId);
652 EXPECT_EQ(ret, SOFTBUS_TRANS_INVALID_DATA_LENGTH);
653 TransDataListDeinit();
654 }
655 } // namespace OHOS
656