1 /*
2 * Copyright (c) 2021 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_manager.c"
20 #include "client_trans_tcp_direct_manager.h"
21 #include "client_trans_tcp_direct_message.c"
22 #include "client_trans_tcp_direct_listener.c"
23 #include "client_trans_tcp_direct_message.h"
24 #include "client_trans_session_manager.h"
25 #include "client_trans_session_callback.h"
26 #include "session.h"
27 #include "softbus_def.h"
28 #include "softbus_errcode.h"
29 #include "softbus_app_info.h"
30 #include "softbus_feature_config.h"
31 #include "softbus_log.h"
32 #include "softbus_access_token_test.h"
33 #include "softbus_conn_interface.h"
34 #include "softbus_socket.h"
35
36 #define MAX_LEN 2048
37 #define TEST_FD 10
38 #define PKG_LEN 32
39 #define RECV_BUF "testrecvBuf"
40 #define BUF_LEN 10
41 #define SESSIONKEY_LEN 32
42 #define INVALID_VALUE (-1)
43
44 #define TRANS_TEST_SESSION_ID 10
45 #define TRANS_TEST_CHANNEL_ID 1000
46 #define TRANS_TEST_FILE_ENCRYPT 10
47 #define TRANS_TEST_ALGORITHM 1
48 #define TRANS_TEST_CRC 1
49 #define TRANS_TEST_FD 1000
50 #define TRANS_TEST_ADDR_INFO_NUM 2
51 #define TRANS_TEST_INVALID_SESSION_ID (-1)
52
53 using namespace testing::ext;
54
55 namespace OHOS {
56 const char *g_pkgName = "dms";
57 const char *g_sessionName = "ohos.distributedschedule.dms.test";
58 const char *g_networkid = "ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00";
59 const char *g_deviceId = "ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF0";
60 const char *g_groupId = "TEST_GROUP_ID";
61 static const char *g_sessionkey = "clientkey";
62 static int32_t g_fd = socket(AF_INET, SOCK_STREAM, 0);
63 static SessionAttribute g_sessionAttr = {
64 .dataType = TYPE_BYTES,
65 };
66
67 class TransTcpDirectTest : public testing::Test {
68 public:
TransTcpDirectTest()69 TransTcpDirectTest()
70 {
71 }
~TransTcpDirectTest()72 ~TransTcpDirectTest()
73 {
74 }
75 static void SetUpTestCase(void);
76 static void TearDownTestCase(void);
SetUp()77 void SetUp() override
78 {
79 }
TearDown()80 void TearDown() override
81 {
82 }
83 };
84
SetUpTestCase(void)85 void TransTcpDirectTest::SetUpTestCase(void)
86 {
87 int32_t ret = TransClientInit();
88 ASSERT_EQ(ret, SOFTBUS_OK);
89 SetAceessTokenPermission("dsoftbusTransTest");
90 }
91
TearDownTestCase(void)92 void TransTcpDirectTest::TearDownTestCase(void)
93 {
94 }
95
OnSessionOpened(int sessionId,int result)96 static int OnSessionOpened(int sessionId, int result)
97 {
98 LOG_INFO("session opened,sesison id = %d\r\n", sessionId);
99 return SOFTBUS_OK;
100 }
101
OnSessionClosed(int sessionId)102 static void OnSessionClosed(int sessionId)
103 {
104 LOG_INFO("session closed, session id = %d\r\n", sessionId);
105 }
106
OnBytesReceived(int sessionId,const void * data,unsigned int len)107 static void OnBytesReceived(int sessionId, const void *data, unsigned int len)
108 {
109 LOG_INFO("session bytes received, session id = %d\r\n", sessionId);
110 }
111
OnMessageReceived(int sessionId,const void * data,unsigned int len)112 static void OnMessageReceived(int sessionId, const void *data, unsigned int len)
113 {
114 LOG_INFO("session msg received, session id = %d\r\n", sessionId);
115 }
116
117 static ISessionListener g_sessionlistener = {
118 .OnSessionOpened = OnSessionOpened,
119 .OnSessionClosed = OnSessionClosed,
120 .OnBytesReceived = OnBytesReceived,
121 .OnMessageReceived = OnMessageReceived,
122 };
123
124 /**
125 * @tc.name: CreateSessionServerTest001
126 * @tc.desc: extern module active publish, use the wrong parameter.
127 * @tc.type: FUNC
128 * @tc.require:I5HQGA
129
130 */
131 HWTEST_F(TransTcpDirectTest, CreateSessionServerTest001, TestSize.Level0)
132 {
133 int ret;
134 ret = CreateSessionServer(NULL, g_sessionName, &g_sessionlistener);
135 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
136
137 ret = CreateSessionServer(g_pkgName, NULL, &g_sessionlistener);
138 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
139
140 ret = CreateSessionServer(g_pkgName, g_sessionName, NULL);
141 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
142
143 ret = CreateSessionServer(g_pkgName, g_sessionName, &g_sessionlistener);
144 EXPECT_EQ(SOFTBUS_OK, ret);
145
146 ret = RemoveSessionServer(g_pkgName, g_sessionName);
147 EXPECT_EQ(SOFTBUS_OK, ret);
148 }
149
150 /**
151 * @tc.name: CreateSessionServerTest002
152 * @tc.desc: extern module active publish, use the normal parameter.
153 * @tc.type: FUNC
154 * @tc.require:I5HQGA
155 */
156 HWTEST_F(TransTcpDirectTest, CreateSessionServerTest002, TestSize.Level0)
157 {
158 int ret;
159 ret = CreateSessionServer(g_pkgName, g_sessionName, &g_sessionlistener);
160 EXPECT_EQ(SOFTBUS_OK, ret);
161
162 ret = RemoveSessionServer(g_pkgName, g_sessionName);
163 EXPECT_EQ(SOFTBUS_OK, ret);
164 }
165
166 /**
167 * @tc.name: CreateSessionServerTest003
168 * @tc.desc: extern module active publish, use the same normal parameter.
169 * @tc.type: FUNC
170 * @tc.require:I5HQGA
171 */
172 HWTEST_F(TransTcpDirectTest, CreateSessionServerTest003, TestSize.Level0)
173 {
174 int ret;
175 ret = CreateSessionServer(g_pkgName, g_sessionName, &g_sessionlistener);
176 EXPECT_EQ(SOFTBUS_OK, ret);
177
178 ret = CreateSessionServer(g_pkgName, g_sessionName, &g_sessionlistener);
179 EXPECT_EQ(SOFTBUS_OK, ret);
180
181 ret = RemoveSessionServer(g_pkgName, g_sessionName);
182 EXPECT_EQ(SOFTBUS_OK, ret);
183 }
184
185 /**
186 * @tc.name: CreateSessionServerTest004
187 * @tc.desc: extern module active publish, create 11 sessionServer, succ 10, failed at 11th.
188 * @tc.type: FUNC
189 * @tc.require:I5HQGA
190 */
191 HWTEST_F(TransTcpDirectTest, CreateSessionServerTest004, TestSize.Level0)
192 {
193 int ret, i;
194 char const *sessionName[MAX_SESSION_SERVER_NUMBER + 1] = {
195 "ohos.distributedschedule.dms.test0",
196 "ohos.distributedschedule.dms.test1",
197 "ohos.distributedschedule.dms.test2",
198 "ohos.distributedschedule.dms.test3",
199 "ohos.distributedschedule.dms.test4",
200 "ohos.distributedschedule.dms.test5",
201 "ohos.distributedschedule.dms.test6",
202 "ohos.distributedschedule.dms.test7",
203 "ohos.distributedschedule.dms.test8",
204 "ohos.distributedschedule.dms.test9",
205 "ohos.distributedschedule.dms.test10"
206 };
207
208 for (i = 0; i < MAX_SESSION_SERVER_NUMBER; i++) {
209 ret = CreateSessionServer(g_pkgName, sessionName[i], &g_sessionlistener);
210 EXPECT_EQ(SOFTBUS_OK, ret);
211 }
212 ret = CreateSessionServer(g_pkgName, sessionName[i], &g_sessionlistener);
213 EXPECT_EQ(SOFTBUS_INVALID_NUM, ret);
214
215 for (i = 0; i < MAX_SESSION_SERVER_NUMBER; i++) {
216 ret = RemoveSessionServer(g_pkgName, sessionName[i]);
217 EXPECT_EQ(SOFTBUS_OK, ret);
218 }
219 }
220
221 /**
222 * @tc.name: RemoveSessionServerTest001
223 * @tc.desc: extern module active publish, use the wrong parameter.
224 * @tc.type: FUNC
225 * @tc.require:
226 */
227 HWTEST_F(TransTcpDirectTest, RemoveSessionServerTest001, TestSize.Level0)
228 {
229 int ret;
230 ret = RemoveSessionServer(NULL, g_sessionName);
231 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
232
233 ret = RemoveSessionServer(g_pkgName, NULL);
234 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
235 }
236
237 /**
238 * @tc.name: RemoveSessionServerTest002
239 * @tc.desc: extern module active publish, use the same parameter.
240 * @tc.type: FUNC
241 * @tc.require:I5HQGA
242 */
243 HWTEST_F(TransTcpDirectTest, RemoveSessionServerTest002, TestSize.Level0)
244 {
245 int ret;
246 ret = CreateSessionServer(g_pkgName, g_sessionName, &g_sessionlistener);
247 EXPECT_EQ(SOFTBUS_OK, ret);
248
249 ret = RemoveSessionServer(g_pkgName, g_sessionName);
250 EXPECT_EQ(SOFTBUS_OK, ret);
251
252 ret = RemoveSessionServer(g_pkgName, g_sessionName);
253 EXPECT_EQ(SOFTBUS_OK, ret);
254 }
255
256 /**
257 * @tc.name: OpenSessionTest001
258 * @tc.desc: extern module active publish, use the wrong parameter.
259 * @tc.type: FUNC
260 * @tc.require:I5HQGA
261 */
262 HWTEST_F(TransTcpDirectTest, OpenSessionTest001, TestSize.Level0)
263 {
264 int ret;
265 g_sessionAttr.dataType = TYPE_BYTES;
266
267 ret = OpenSession(NULL, g_sessionName, g_networkid, g_groupId, &g_sessionAttr);
268 EXPECT_GE(SOFTBUS_OK, ret);
269
270 ret = OpenSession(g_sessionName, NULL, g_networkid, g_groupId, &g_sessionAttr);
271 EXPECT_GE(SOFTBUS_OK, ret);
272
273 ret = OpenSession(g_sessionName, g_sessionName, NULL, g_groupId, &g_sessionAttr);
274 EXPECT_GE(SOFTBUS_OK, ret);
275
276 ret = OpenSession(g_sessionName, g_sessionName, g_networkid, NULL, &g_sessionAttr);
277 EXPECT_GE(SOFTBUS_OK, ret);
278
279 ret = OpenSession(g_sessionName, g_sessionName, g_networkid, g_groupId, NULL);
280 EXPECT_GE(SOFTBUS_OK, ret);
281
282 g_sessionAttr.dataType = TYPE_BUTT;
283 ret = OpenSession(g_sessionName, g_sessionName, g_networkid, g_groupId, &g_sessionAttr);
284 g_sessionAttr.dataType = TYPE_BYTES;
285 EXPECT_GE(SOFTBUS_OK, ret);
286 }
287
288 /**
289 * @tc.name: SendBytesTest001
290 * @tc.desc: extern module active publish, use the wrong parameter.
291 * @tc.type: FUNC
292 * @tc.require:
293 */
294 HWTEST_F(TransTcpDirectTest, SendBytesTest001, TestSize.Level0)
295 {
296 int ret;
297 int sessionId = 1;
298 const char *data = "testdata";
299 uint32_t len = strlen(data);
300 uint32_t maxLen;
301
302 ret = SendBytes(-1, data, len);
303 EXPECT_NE(SOFTBUS_OK, ret);
304
305 ret = SendBytes(sessionId, NULL, len);
306 EXPECT_NE(SOFTBUS_OK, ret);
307
308 ret = SendBytes(sessionId, data, 0);
309 EXPECT_NE(SOFTBUS_OK, ret);
310
311 ret = SoftbusGetConfig(SOFTBUS_INT_MAX_BYTES_LENGTH, (unsigned char *)&maxLen, sizeof(maxLen));
312 ASSERT_EQ(SOFTBUS_OK, ret);
313 ret = SendMessage(sessionId, data, maxLen + 1);
314 EXPECT_NE(SOFTBUS_OK, ret);
315 }
316
317 /**
318 * @tc.name: SendMessageTest001
319 * @tc.desc: extern module active publish, use the wrong parameter.
320 * @tc.type: FUNC
321 * @tc.require:
322 */
323 HWTEST_F(TransTcpDirectTest, SendMessageTest001, TestSize.Level0)
324 {
325 int ret;
326 int sessionId = 1;
327 const char *data = "testdata";
328 uint32_t len = strlen(data);
329 uint32_t maxLen;
330
331 ret = SendMessage(-1, data, len);
332 EXPECT_NE(SOFTBUS_OK, ret);
333
334 ret = SendMessage(sessionId, NULL, len);
335 EXPECT_NE(SOFTBUS_OK, ret);
336
337 ret = SendMessage(sessionId, data, 0);
338 EXPECT_NE(SOFTBUS_OK, ret);
339
340 ret = SoftbusGetConfig(SOFTBUS_INT_MAX_MESSAGE_LENGTH, (unsigned char *)&maxLen, sizeof(maxLen));
341 ASSERT_EQ(SOFTBUS_OK, ret);
342 ret = SendMessage(sessionId, data, maxLen + 1);
343 EXPECT_NE(SOFTBUS_OK, ret);
344 }
345
346 /**
347 * @tc.name: TransClientGetTdcDataBufByChannelTest001
348 * @tc.desc: improve branch coverage, use the wrong or normal parameter.
349 * @tc.type: FUNC
350 * @tc.require:
351 */
352 HWTEST_F(TransTcpDirectTest, TransClientGetTdcDataBufByChannelTest001, TestSize.Level0)
353 {
354 int ret;
355 int channelId = 0;
356 int fd = TEST_FD;
357 size_t len = BUF_LEN;
358
359 ret = TransClientGetTdcDataBufByChannel(channelId, NULL, NULL);
360 EXPECT_EQ(SOFTBUS_ERR, ret);
361
362 ret = TransClientGetTdcDataBufByChannel(channelId, &fd, &len);
363 EXPECT_EQ(SOFTBUS_ERR, ret);
364
365 ret = TransDataListInit();
366 EXPECT_EQ(SOFTBUS_OK, ret);
367
368 ret = TransClientGetTdcDataBufByChannel(channelId, &fd, &len);
369 EXPECT_EQ(SOFTBUS_ERR, ret);
370
371 ret = TransAddDataBufNode(channelId, fd);
372 EXPECT_EQ(SOFTBUS_OK, ret);
373
374 ret = TransClientGetTdcDataBufByChannel(channelId, &fd, &len);
375 EXPECT_EQ(SOFTBUS_OK, ret);
376
377 ret = TransDelDataBufNode(channelId);
378 EXPECT_EQ(SOFTBUS_OK, ret);
379
380 TransDataListDeinit();
381 }
382
383 /**
384 * @tc.name: TransClientUpdateTdcDataBufWInfoTest001
385 * @tc.desc: improve branch coverage, use the wrong or normal parameter.
386 * @tc.type: FUNC
387 * @tc.require:
388 */
389 HWTEST_F(TransTcpDirectTest, TransClientUpdateTdcDataBufWInfoTest001, TestSize.Level0)
390 {
391 int ret;
392 int channelId = 0;
393 int fd = TEST_FD;
394 const char *recvBuf = RECV_BUF;
395 int recvLen = MAX_LEN;
396
397 ret = TransClientUpdateTdcDataBufWInfo(channelId, NULL, recvLen);
398 EXPECT_EQ(SOFTBUS_ERR, ret);
399
400 ret = TransClientUpdateTdcDataBufWInfo(channelId, const_cast<char *>(recvBuf), recvLen);
401 EXPECT_EQ(SOFTBUS_ERR, ret);
402
403 ret = TransDataListInit();
404 EXPECT_EQ(SOFTBUS_OK, ret);
405
406 ret = TransClientUpdateTdcDataBufWInfo(channelId, const_cast<char *>(recvBuf), recvLen);
407 EXPECT_EQ(SOFTBUS_ERR, ret);
408
409 ret = TransAddDataBufNode(channelId, fd);
410 EXPECT_EQ(SOFTBUS_OK, ret);
411
412 ret = TransClientUpdateTdcDataBufWInfo(channelId, const_cast<char *>(recvBuf), recvLen);
413 EXPECT_EQ(SOFTBUS_ERR, ret);
414
415 recvLen = strlen(recvBuf);
416 ret = TransClientUpdateTdcDataBufWInfo(channelId, const_cast<char *>(recvBuf), recvLen);
417 EXPECT_EQ(SOFTBUS_OK, ret);
418
419 ret = TransDelDataBufNode(channelId);
420 EXPECT_EQ(SOFTBUS_OK, ret);
421
422 TransDataListDeinit();
423 }
424
425 /**
426 * @tc.name: TransTdcRecvDataTest001
427 * @tc.desc: improve branch coverage, use the wrong or normal parameter.
428 * @tc.type: FUNC
429 * @tc.require:
430 */
431 HWTEST_F(TransTcpDirectTest, TransTdcRecvDataTest001, TestSize.Level0)
432 {
433 int ret;
434 int channelId = -1;
435 int fd = -1;
436
437 ret = TransTdcRecvData(channelId);
438 EXPECT_EQ(SOFTBUS_ERR, ret);
439
440 ret = TransDataListInit();
441 ASSERT_EQ(ret, SOFTBUS_OK);
442
443 channelId = 0;
444 ret = TransAddDataBufNode(channelId, fd);
445 ASSERT_EQ(ret, SOFTBUS_OK);
446
447 ret = TransTdcRecvData(channelId);
448 EXPECT_EQ(SOFTBUS_ERR, ret);
449
450 ret = TransDelDataBufNode(channelId);
451 EXPECT_EQ(SOFTBUS_OK, ret);
452
453 TransDataListDeinit();
454 }
455 /**
456 * @tc.name: TransTdcPackDataTest001
457 * @tc.desc: TransTdcPackData, use the wrong or normal parameter.
458 * @tc.type: FUNC
459 * @tc.require:
460 */
461 HWTEST_F(TransTcpDirectTest, TransTdcPackDataTest001, TestSize.Level0)
462 {
463 TcpDirectChannelInfo *channel = (TcpDirectChannelInfo *)SoftBusMalloc(sizeof(TcpDirectChannelInfo));
464 ASSERT_TRUE(channel != nullptr);
465 (void)memset_s(channel, sizeof(TcpDirectChannelInfo), 0, sizeof(TcpDirectChannelInfo));
466 channel->channelId = 1;
467 (void)memcpy_s(channel->detail.sessionKey, SESSIONKEY_LEN, g_sessionkey, strlen(g_sessionkey));
468 channel->detail.channelType = CHANNEL_TYPE_TCP_DIRECT;
469 channel->detail.fd = g_fd;
470 channel->detail.sequence = 1;
471 const char *data = "data";
472 uint32_t len = BUF_LEN;
473 int flags = FLAG_ACK;
474 char *ret = TransTdcPackData(channel, data, len, flags, NULL);
475 EXPECT_TRUE(ret == nullptr);
476 uint32_t outLen = 0;
477 ret = TransTdcPackData(channel, data, len, flags, &outLen);
478 EXPECT_TRUE(ret != nullptr);
479 SoftBusFree(channel);
480 }
481
482 /**
483 * @tc.name: TransTdcProcessPostDataTest001
484 * @tc.desc: TransTdcProcessPostData, use the wrong or normal parameter.
485 * @tc.type: FUNC
486 * @tc.require:
487 */
488 HWTEST_F(TransTcpDirectTest, TransTdcProcessPostDataTest001, TestSize.Level0)
489 {
490 TcpDirectChannelInfo *channel = (TcpDirectChannelInfo *)SoftBusMalloc(sizeof(TcpDirectChannelInfo));
491 ASSERT_TRUE(channel != nullptr);
492 (void)memset_s(channel, sizeof(TcpDirectChannelInfo), 0, sizeof(TcpDirectChannelInfo));
493 channel->channelId = 1;
494 (void)memcpy_s(channel->detail.sessionKey, SESSIONKEY_LEN, g_sessionkey, strlen(g_sessionkey));
495 channel->detail.channelType = CHANNEL_TYPE_TCP_DIRECT;
496 channel->detail.fd = g_fd;
497 channel->detail.sequence = 1;
498 const char *data = "data";
499 uint32_t len = BUF_LEN;
500 int flags = FLAG_ACK;
501 int32_t ret = TransTdcProcessPostData(channel, data, len, flags);
502 EXPECT_TRUE(ret != SOFTBUS_OK);
503 SoftBusFree(channel);
504 }
505
506 /**
507 * @tc.name: TransTdcDecryptTest001
508 * @tc.desc: TransTdcDecrypt, use the wrong or normal parameter.
509 * @tc.type: FUNC
510 * @tc.require:
511 */
512 HWTEST_F(TransTcpDirectTest, TransTdcDecryptTest001, TestSize.Level0)
513 {
514 char *out = nullptr;
515 uint32_t outLen = 0;
516 uint32_t inLen = 0;
517 int32_t ret = TransTdcDecrypt(nullptr, nullptr, inLen, out, &outLen);
518 EXPECT_TRUE(ret != SOFTBUS_OK);
519 }
520
521 /**
522 * @tc.name: TransTdcEncryptWithSeqTest001
523 * @tc.desc: TransTdcEncryptWithSeq, use the wrong or normal parameter.
524 * @tc.type: FUNC
525 * @tc.require:
526 */
527 HWTEST_F(TransTcpDirectTest, TransTdcEncryptWithSeqTest001, TestSize.Level0)
528 {
529 const char *in = "data";
530 char *out = nullptr;
531 uint32_t outLen = 0;
532 uint32_t inLen = (uint32_t)strlen(in);
533 int32_t seqNum = BUF_LEN;
534 int32_t ret = TransTdcEncryptWithSeq(nullptr, seqNum, in, inLen, out, &outLen);
535 EXPECT_TRUE(ret != SOFTBUS_OK);
536
537 ret = TransTdcEncryptWithSeq(g_sessionkey, seqNum, nullptr, inLen, out, &outLen);
538 EXPECT_TRUE(ret != SOFTBUS_OK);
539
540 ret = TransTdcEncryptWithSeq(g_sessionkey, seqNum, in, inLen, out, &outLen);
541 EXPECT_TRUE(ret != SOFTBUS_OK);
542 }
543
544 /**
545 * @tc.name: TransTdcSetPendingPacketTest001
546 * @tc.desc: TransTdcSetPendingPacket, use the wrong or normal parameter.
547 * @tc.type: FUNC
548 * @tc.require:
549 */
550 HWTEST_F(TransTcpDirectTest, TransTdcSetPendingPacketTest001, TestSize.Level0)
551 {
552 int32_t channelId = 1;
553 const char *data = "data";
554 uint32_t len = 0;
555 int32_t seqNum = 1;
556 int type = 1;
557 int32_t ret = TransTdcSetPendingPacket(channelId, data, len);
558 EXPECT_TRUE(ret == SOFTBUS_ERR);
559 ret = PendingInit(type);
560 ASSERT_TRUE(ret == SOFTBUS_OK);
561
562 ret = ProcPendingPacket(channelId, seqNum, type);
563 EXPECT_TRUE(ret != SOFTBUS_OK);
564 len = ACK_SIZE;
565 channelId = INVALID_VALUE;
566 ret = TransTdcSetPendingPacket(channelId, data, len);
567 EXPECT_TRUE(ret == SOFTBUS_ERR);
568 channelId = 1;
569 ret = TransTdcSetPendingPacket(channelId, data, len);
570 EXPECT_TRUE(ret == SOFTBUS_ERR);
571 PendingDeinit(type);
572 }
573
574 /**
575 * @tc.name: TransTdcSendAckTest001
576 * @tc.desc: TransTdcSendAck, use the wrong or normal parameter.
577 * @tc.type: FUNC
578 * @tc.require:
579 */
580 HWTEST_F(TransTcpDirectTest, TransTdcSendAckTest001, TestSize.Level0)
581 {
582 int32_t seq = 1;
583 TcpDirectChannelInfo *channel = (TcpDirectChannelInfo*)SoftBusMalloc(sizeof(TcpDirectChannelInfo));
584 ASSERT_TRUE(channel != nullptr);
585 (void)memset_s(channel, sizeof(TcpDirectChannelInfo), 0, sizeof(TcpDirectChannelInfo));
586 channel->channelId = 1;
587 (void)memcpy_s(channel->detail.sessionKey, SESSIONKEY_LEN, g_sessionkey, strlen(g_sessionkey));
588 channel->detail.channelType = CHANNEL_TYPE_TCP_DIRECT;
589 channel->detail.fd = g_fd;
590 channel->detail.sequence = 1;
591 int32_t ret = TransTdcSendAck(nullptr, seq);
592 EXPECT_TRUE(ret != SOFTBUS_OK);
593
594 ret = TransTdcSendAck(channel, seq);
595 EXPECT_TRUE(ret != SOFTBUS_OK);
596 SoftBusFree(channel);
597 }
598
599 /**
600 * @tc.name: TransGetDataBufSizeTest001
601 * @tc.desc: TransGetDataBufSize, use the wrong or normal parameter.
602 * @tc.type: FUNC
603 * @tc.require:
604 */
605 HWTEST_F(TransTcpDirectTest, TransGetDataBufSizeTest001, TestSize.Level0)
606 {
607 uint32_t ret = TransGetDataBufSize();
608 EXPECT_TRUE(ret == MIN_BUF_LEN);
609
610 int32_t res = TransGetDataBufMaxSize();
611 EXPECT_TRUE(res == SOFTBUS_OK);
612 }
613
614 /**
615 * @tc.name: TransDestroyDataBufTest001
616 * @tc.desc: TransDestroyDataBuf, use the wrong or normal parameter.
617 * @tc.type: FUNC
618 * @tc.require:
619 */
620 HWTEST_F(TransTcpDirectTest, TransDestroyDataBufTest001, TestSize.Level0)
621 {
622 int32_t channelId = 1;
623 int32_t fd = TEST_FD;
624 int32_t ret = TransDestroyDataBuf();
625 EXPECT_TRUE(ret != SOFTBUS_OK);
626
627 ret = TransDataListInit();
628 ASSERT_EQ(ret, SOFTBUS_OK);
629
630 ret = TransAddDataBufNode(channelId, fd);
631 ASSERT_EQ(ret, SOFTBUS_OK);
632
633 ret = TransDestroyDataBuf();
634 EXPECT_TRUE(ret == SOFTBUS_OK);
635 TransDataListDeinit();
636 }
637
638 /**
639 * @tc.name: TransGetDataBufNodeByIdTest001
640 * @tc.desc: TransGetDataBufNodeById, use the wrong or normal parameter.
641 * @tc.type: FUNC
642 * @tc.require:
643 */
644 HWTEST_F(TransTcpDirectTest, TransGetDataBufNodeByIdTest001, TestSize.Level0)
645 {
646 int32_t channelId = 1;
647 int32_t fd = TEST_FD;
648 ClientDataBuf *data = TransGetDataBufNodeById(channelId);
649 EXPECT_TRUE(data == nullptr);
650
651 int32_t ret = TransDataListInit();
652 ASSERT_EQ(ret, SOFTBUS_OK);
653
654 ret = TransAddDataBufNode(channelId, fd);
655 ASSERT_EQ(ret, SOFTBUS_OK);
656
657 data = TransGetDataBufNodeById(channelId);
658 EXPECT_TRUE(data != nullptr);
659
660 TransDataListDeinit();
661 }
662
663 /**
664 * @tc.name: TransTdcProcessDataByFlagTest001
665 * @tc.desc: TransTdcProcessDataByFlag, use the wrong or normal parameter.
666 * @tc.type: FUNC
667 * @tc.require:
668 */
669 HWTEST_F(TransTcpDirectTest, TransTdcProcessDataByFlagTest001, TestSize.Level0)
670 {
671 uint32_t flag = FLAG_BYTES;
672 int32_t seqNum = 1;
673 const char *plain = "plain";
674 uint32_t plainLen = 0;
675 flag = FLAG_ACK;
676 int32_t ret = TransTdcProcessDataByFlag(flag, seqNum, nullptr, plain, plainLen);
677 EXPECT_TRUE(ret == SOFTBUS_OK);
678 }
679
680 /**
681 * @tc.name: TransTdcProcessDataTest001
682 * @tc.desc: TransTdcProcessData, use the wrong or normal parameter.
683 * @tc.type: FUNC
684 * @tc.require:
685 */
686 HWTEST_F(TransTcpDirectTest, TransTdcProcessDataTest001, TestSize.Level0)
687 {
688 int32_t channelId = 1;
689 int32_t fd = TEST_FD;
690 ChannelInfo *info = (ChannelInfo *)SoftBusCalloc(sizeof(ChannelInfo));
691 ASSERT_TRUE(info != nullptr);
692 (void)memset_s(info, sizeof(ChannelInfo), 0, sizeof(ChannelInfo));
693 info->peerSessionName = (char *)g_sessionName;
694 info->channelId = 1;
695 info->channelType = CHANNEL_TYPE_TCP_DIRECT;
696 info->sessionKey = (char *)g_sessionkey;
697 info->fd = g_fd;
698
699 int32_t ret = TransTdcProcessData(channelId);
700 EXPECT_TRUE(ret == SOFTBUS_ERR);
701 IClientSessionCallBack *cb = GetClientSessionCb();
702 ret = TransTdcManagerInit(cb);
703 ASSERT_EQ(ret, SOFTBUS_OK);
704
705 ret = ClientTransTdcOnChannelOpened(g_sessionName, info);
706 EXPECT_TRUE(ret != SOFTBUS_OK);
707
708 ret = TransTdcProcessData(channelId);
709 EXPECT_TRUE(ret == SOFTBUS_ERR);
710
711 ret = TransDataListInit();
712 ASSERT_EQ(ret, SOFTBUS_OK);
713
714 ret = TransAddDataBufNode(channelId, fd);
715 ASSERT_EQ(ret, SOFTBUS_OK);
716
717 ret = TransTdcProcessData(channelId);
718 EXPECT_TRUE(ret != SOFTBUS_OK);
719
720 TransDataListDeinit();
721 TransTdcManagerDeinit();
722 SoftBusFree(info);
723 }
724
725 /**
726 * @tc.name: TransResizeDataBufferTest001
727 * @tc.desc: TransResizeDataBuffer, use the wrong or normal parameter.
728 * @tc.type: FUNC
729 * @tc.require:
730 */
731 HWTEST_F(TransTcpDirectTest, TransResizeDataBufferTest001, TestSize.Level0)
732 {
733 ClientDataBuf *oldBuf = (ClientDataBuf *)SoftBusCalloc(sizeof(ClientDataBuf));
734 ASSERT_TRUE(oldBuf != nullptr);
735 (void)memset_s(oldBuf, sizeof(ClientDataBuf), 0, sizeof(ClientDataBuf));
736 int32_t ret = TransResizeDataBuffer(oldBuf, PKG_LEN);
737 EXPECT_TRUE(ret != SOFTBUS_OK);
738
739 (void)memcpy_s(oldBuf->data, strlen("data"), "data", strlen("data"));
740 oldBuf->size = BUF_LEN;
741 (void)memcpy_s(oldBuf->w, strlen("oldbulf"), "oldbulf", strlen("oldbulf"));
742
743 ret = TransResizeDataBuffer(oldBuf, PKG_LEN);
744 EXPECT_TRUE(ret != SOFTBUS_OK);
745 SoftBusFree(oldBuf);
746 }
747
748 /**
749 * @tc.name: TransTdcProcAllDataTest001
750 * @tc.desc: TransTdcProcAllData, use the wrong or normal parameter.
751 * @tc.type: FUNC
752 * @tc.require:
753 */
754 HWTEST_F(TransTcpDirectTest, TransTdcProcAllDataTest001, TestSize.Level0)
755 {
756 int32_t channelId = 1;
757 int32_t fd = TEST_FD;
758 ClientDataBuf *oldBuf = (ClientDataBuf *)SoftBusCalloc(sizeof(ClientDataBuf));
759 ASSERT_TRUE(oldBuf != nullptr);
760 (void)memset_s(oldBuf, sizeof(ClientDataBuf), 0, sizeof(ClientDataBuf));
761
762 int32_t ret = TransTdcProcAllData(channelId);
763 EXPECT_TRUE(ret != SOFTBUS_OK);
764
765 ret = TransDataListInit();
766 ASSERT_EQ(ret, SOFTBUS_OK);
767
768 ret = TransAddDataBufNode(channelId, fd);
769 ASSERT_EQ(ret, SOFTBUS_OK);
770
771 ret = TransTdcProcAllData(channelId);
772 EXPECT_TRUE(ret == SOFTBUS_OK);
773 TransDataListDeinit();
774 SoftBusFree(oldBuf);
775 }
776
777 /**
778 * @tc.name: ClientTdcOnConnectEventTest001
779 * @tc.desc: ClientTdcOnConnectEvent, use the wrong or normal parameter.
780 * @tc.type: FUNC
781 * @tc.require:
782 */
783 HWTEST_F(TransTcpDirectTest, ClientTdcOnConnectEventTest001, TestSize.Level0)
784 {
785 int cfd = 0;
786 int32_t ret = ClientTdcOnConnectEvent(DIRECT_CHANNEL_SERVER_WIFI, cfd, nullptr);
787 EXPECT_TRUE(ret == SOFTBUS_OK);
788 }
789
790 /**
791 * @tc.name: ClientTdcOnDataEventTest001
792 * @tc.desc: ClientTdcOnDataEvent, use the wrong or normal parameter.
793 * @tc.type: FUNC
794 * @tc.require:
795 */
796 HWTEST_F(TransTcpDirectTest, ClientTdcOnDataEventTest001, TestSize.Level0)
797 {
798 int events = SOFTBUS_SOCKET_IN;
799 int32_t fd = g_fd;
800 ChannelInfo *info = (ChannelInfo *)SoftBusCalloc(sizeof(ChannelInfo));
801 ASSERT_TRUE(info != nullptr);
802 (void)memset_s(info, sizeof(ChannelInfo), 0, sizeof(ChannelInfo));
803 info->peerSessionName = (char *)g_sessionName;
804 info->channelId = 1;
805 info->channelType = CHANNEL_TYPE_TCP_DIRECT;
806 info->sessionKey = (char *)g_sessionkey;
807 info->fd = g_fd;
808 IClientSessionCallBack *cb = GetClientSessionCb();
809 int32_t ret = TransTdcManagerInit(cb);
810 ASSERT_EQ(ret, SOFTBUS_OK);
811
812 ret = ClientTransTdcOnChannelOpened(g_sessionName, info);
813 EXPECT_TRUE(ret != SOFTBUS_OK);
814
815 ret = ClientTdcOnDataEvent(DIRECT_CHANNEL_SERVER_WIFI, events, fd);
816 EXPECT_TRUE(ret != SOFTBUS_OK);
817 TransTdcManagerDeinit();
818 }
819
820 /**
821 * @tc.name: TransGetNewTcpChannelTest001
822 * @tc.desc: TransGetNewTcpChannel, use the wrong or normal parameter.
823 * @tc.type: FUNC
824 * @tc.require:
825 */
826 HWTEST_F(TransTcpDirectTest, TransGetNewTcpChannelTest001, TestSize.Level0)
827 {
828 int32_t channelId = 1;
829 TcpDirectChannelInfo *info = TransGetNewTcpChannel(NULL);
830 ASSERT_EQ(info, nullptr);
831 ChannelInfo *channelInfo = (ChannelInfo *)SoftBusCalloc(sizeof(ChannelInfo));
832 ASSERT_TRUE(channelInfo != nullptr);
833 (void)memset_s(channelInfo, sizeof(ChannelInfo), 0, sizeof(ChannelInfo));
834 channelInfo->peerSessionName = (char *)g_sessionName;
835 channelInfo->channelId = 1;
836 channelInfo->channelType = CHANNEL_TYPE_TCP_DIRECT;
837 channelInfo->sessionKey = (char *)g_sessionkey;
838 channelInfo->fd = g_fd;
839
840 IClientSessionCallBack *cb = GetClientSessionCb();
841 int32_t ret = TransTdcManagerInit(cb);
842 ASSERT_EQ(ret, SOFTBUS_OK);
843
844 ret = ClientTransTdcOnChannelOpened(g_sessionName, channelInfo);
845 EXPECT_TRUE(ret != SOFTBUS_OK);
846
847 ret = ClientTransCheckTdcChannelExist(channelId);
848 EXPECT_EQ(ret, SOFTBUS_OK);
849 SoftBusFree(channelInfo);
850 }
851
852 /**
853 * @tc.name: TransTdcProcessDataByFlagTest002
854 * @tc.desc: TransTdcProcessDataByFlag, use different parameters.
855 * @tc.type: FUNC
856 * @tc.require:
857 */
858 HWTEST_F(TransTcpDirectTest, TransTdcProcessDataByFlagTest002, TestSize.Level0)
859 {
860 TcpDirectChannelInfo *channel = (TcpDirectChannelInfo *)SoftBusCalloc(sizeof(TcpDirectChannelInfo));
861 ASSERT_TRUE(channel != nullptr);
862
863 int ret = memcpy_s(channel->detail.sessionKey, SESSIONKEY_LEN, g_sessionkey, strlen(g_sessionkey));
864 ASSERT_EQ(ret, EOK);
865 channel->channelId = TRANS_TEST_CHANNEL_ID;
866 channel->detail.channelType = CHANNEL_TYPE_TCP_DIRECT;
867 channel->detail.fd = TRANS_TEST_FD;
868 channel->detail.sequence = 1;
869 int32_t seqNum = 1;
870 const char *plain = "plain";
871
872 ret = TransTdcProcessDataByFlag(FLAG_BYTES, seqNum, channel, plain, (uint32_t)strlen(plain));
873 EXPECT_NE(ret, SOFTBUS_OK);
874
875 ret = TransTdcProcessDataByFlag(FLAG_ACK, seqNum, channel, plain, (uint32_t)strlen(plain));
876 EXPECT_EQ(ret, SOFTBUS_OK);
877
878 ret = TransTdcProcessDataByFlag(FLAG_MESSAGE, seqNum, channel, plain, (uint32_t)strlen(plain));
879 EXPECT_NE(ret, SOFTBUS_OK);
880
881 ret = TransTdcProcessDataByFlag(FILE_FIRST_FRAME, seqNum, channel, plain, (uint32_t)strlen(plain));
882 EXPECT_EQ(ret, SOFTBUS_ERR);
883
884 SoftBusFree(channel);
885 }
886
887 /**
888 * @tc.name: TransTdcProcAllDataTest002
889 * @tc.desc: TransTdcProcAllData, use different parameters.
890 * @tc.type: FUNC
891 * @tc.require:
892 */
893 HWTEST_F(TransTcpDirectTest, TransTdcProcAllDataTest002, TestSize.Level0)
894 {
895 int32_t ret = TransDataListInit();
896 ASSERT_EQ(ret, SOFTBUS_OK);
897
898 ret = TransAddDataBufNode(TRANS_TEST_CHANNEL_ID, TRANS_TEST_FD);
899 ASSERT_EQ(ret, SOFTBUS_OK);
900 ret = TransTdcProcAllData(TRANS_TEST_CHANNEL_ID);
901 EXPECT_EQ(ret, SOFTBUS_OK);
902
903 TransDataListDeinit();
904 }
905
906 /**
907 * @tc.name: TransTdcDecryptTest002
908 * @tc.desc: TransTdcDecrypt, use different parameters.
909 * @tc.type: FUNC
910 * @tc.require:
911 */
912 HWTEST_F(TransTcpDirectTest, TransTdcDecryptTest002, TestSize.Level0)
913 {
914 char output[MAX_LEN] = {0};
915 uint32_t outLen = MAX_LEN;
916 int32_t ret = TransTdcDecrypt(g_sessionkey, RECV_BUF, strlen(RECV_BUF) + 1, output, &outLen);
917 EXPECT_FALSE(ret == SOFTBUS_OK);
918 }
919 }
920