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