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 <cstring>
17 #include <gtest/gtest.h>
18 #include <securec.h>
19
20 #include "client_trans_file.c"
21 #include "client_trans_file_listener.c"
22 #include "client_trans_session_callback.h"
23 #include "client_trans_stream.h"
24 #include "client_trans_udp_manager.h"
25 #include "client_trans_udp_manager.c"
26 #include "file_adapter.c"
27 #include "session.h"
28 #include "softbus_adapter_mem.h"
29
30 using namespace testing::ext;
31
32 namespace OHOS {
33
34 const uint32_t g_keyLen = 10;
35 char g_mySessionName[] = {"my sessionName"};
36 char g_peerSessionName[] = {"peer sessionName"};
37 char g_peerDeviceId[] = {"127.0.0.4"};
38 char g_groupId[] = {"12345"};
39 char g_peerIp[] = {"11111"};
40 char g_sessionKey[] = {"123548246"};
41 char g_myIp[] = {"coms.132465"};
42
TransAddChannelTest()43 UdpChannel *TransAddChannelTest()
44 {
45 UdpChannel *channel = (UdpChannel *)SoftBusCalloc(sizeof(UdpChannel));
46 if (channel == NULL) {
47 return nullptr;
48 }
49 channel->channelId = 1;
50 channel->dfileId = -1;
51 channel->channelId = 1;
52 channel->businessType = 1;
53 channel->isEnable = true;
54 channel->routeType = 1;
55 channel->info.isServer = 0;
56 channel->info.peerUid = 0;
57 channel->info.peerPid = 0;
58 (void)strcpy_s(channel->info.mySessionName, strlen("my sessionName")+1, "my sessionName");
59 (void)strcpy_s(channel->info.peerSessionName, strlen("peer sessionName")+1, "peer sessionName");
60 (void)strcpy_s(channel->info.peerDeviceId, strlen("127.0.0.4")+1, "127.0.0.4");
61 (void)strcpy_s(channel->info.groupId, strlen("12345")+1, "12345");
62 return channel;
63 }
TransAddChannleInfoTest()64 ChannelInfo *TransAddChannleInfoTest()
65 {
66 ChannelInfo *channelInfo = (ChannelInfo *)SoftBusCalloc(sizeof(ChannelInfo));
67 if (channelInfo == NULL) {
68 return nullptr;
69 }
70 channelInfo->channelId = 1;
71 channelInfo->channelType = 1;
72 channelInfo->businessType = 1;
73 channelInfo->fd = 1;
74 channelInfo->isServer = true;
75 channelInfo->isEnabled = true;
76 channelInfo->peerUid = 1;
77 channelInfo->peerPid = 1;
78 channelInfo->groupId = g_groupId;
79 channelInfo->keyLen = g_keyLen;
80 channelInfo->sessionKey = g_sessionKey;
81 channelInfo->peerSessionName = g_peerSessionName;
82 channelInfo->peerDeviceId = g_peerDeviceId;
83 channelInfo->myIp = g_myIp;
84 channelInfo->peerIp = g_peerIp;
85
86 channelInfo->peerPort = 1;
87 channelInfo->routeType = 1;
88 channelInfo->streamType = 1;
89 channelInfo->encrypt = 1;
90 channelInfo->algorithm = 1;
91 channelInfo->crc = 1;
92 channelInfo->isUdpFile = false;
93 return channelInfo;
94 }
95
96 class TransSdkFileTest : public testing::Test {
97 public:
TransSdkFileTest()98 TransSdkFileTest()
99 {}
~TransSdkFileTest()100 ~TransSdkFileTest()
101 {}
102 static void SetUpTestCase(void);
103 static void TearDownTestCase(void);
SetUp()104 void SetUp() override
105 {}
TearDown()106 void TearDown() override
107 {}
108 };
109
SetUpTestCase(void)110 void TransSdkFileTest::SetUpTestCase(void)
111 {
112 IClientSessionCallBack *cb = GetClientSessionCb();
113 int32_t ret = ClientTransUdpMgrInit(cb);
114 EXPECT_TRUE(ret == SOFTBUS_OK);
115 ret = TransFileInit();
116 EXPECT_TRUE(ret == SOFTBUS_OK);
117 }
118
TearDownTestCase(void)119 void TransSdkFileTest::TearDownTestCase(void)
120 {
121 ClientTransUdpMgrDeinit();
122 TransFileDeinit();
123 }
124
OnFileTransErrorTest(int sessionId)125 void OnFileTransErrorTest(int sessionId)
126 {
127 std::cout << "OnFileTransError sessionId = %d\n" << sessionId << std::endl;
128 }
129
OnReceiveFileStartedTest(int sessionId,const char * files,int fileCnt)130 int OnReceiveFileStartedTest(int sessionId, const char *files, int fileCnt)
131 {
132 std::cout << "File receive start sessionId = %d" << sessionId << std::endl;
133 return 0;
134 }
135
OnReceiveFileFinishedTest(int sessionId,const char * files,int fileCnt)136 void OnReceiveFileFinishedTest(int sessionId, const char *files, int fileCnt)
137 {
138 std::cout << "File receive finished sessionId = %d\n" << sessionId << std::endl;
139 }
140
OnReceiveFileProcessTest(int sessionId,const char * firstFile,uint64_t bytesUpload,uint64_t bytesTotal)141 int OnReceiveFileProcessTest(int sessionId, const char *firstFile, uint64_t bytesUpload, uint64_t bytesTotal)
142 {
143 std::cout << "File receive process sessionId = %d\n" << sessionId << std::endl;
144 return 0;
145 }
146
OnSendFileProcessTest(int sessionId,uint64_t bytesUpload,uint64_t bytesTotal)147 int OnSendFileProcessTest(int sessionId, uint64_t bytesUpload, uint64_t bytesTotal)
148 {
149 std::cout << "send process id = " << sessionId << " upload = "
150 << bytesUpload << ", total = " << bytesTotal << std::endl;
151 return 0;
152 }
153
OnSendFileFinishedTest(int sessionId,const char * firstFile)154 int OnSendFileFinishedTest(int sessionId, const char *firstFile)
155 {
156 std::cout << "send finished id = %d," << sessionId << "first file = %s." << firstFile << std::endl;
157 return 0;
158 }
159
DFileMsgReceiverTest(int32_t sessionId,DFileMsgType msgType,const DFileMsg * msg)160 void DFileMsgReceiverTest(int32_t sessionId, DFileMsgType msgType, const DFileMsg *msg)
161 {
162 std::cout << "file receiver id = %d" << sessionId << std::endl;
163 return;
164 }
165
166
167 static IFileSendListener g_fileSendListener = {
168 .OnSendFileProcess = OnSendFileProcessTest,
169 .OnSendFileFinished = OnSendFileFinishedTest,
170 .OnFileTransError = OnFileTransErrorTest,
171 };
172
173 static IFileReceiveListener g_fileRecvListener = {
174 .OnReceiveFileStarted = OnReceiveFileStartedTest,
175 .OnReceiveFileProcess = OnReceiveFileProcessTest,
176 .OnReceiveFileFinished = OnReceiveFileFinishedTest,
177 .OnFileTransError = OnFileTransErrorTest,
178 };
179
180 static DFileMsgReceiver g_fileMsgRecviver = DFileMsgReceiverTest;
181
GenerateAndAddUdpChannel(UdpChannel * channel)182 void GenerateAndAddUdpChannel(UdpChannel *channel)
183 {
184 IClientSessionCallBack *cb = GetClientSessionCb();
185 int32_t ret = ClientTransUdpMgrInit(cb);
186 EXPECT_TRUE(ret == SOFTBUS_OK);
187 channel->channelId = 1;
188 channel->dfileId = 1;
189 channel->businessType = BUSINESS_TYPE_STREAM;
190 memcpy_s(channel->info.mySessionName, SESSION_NAME_SIZE_MAX,
191 "normal sessionName", strlen("normal sessionName"));
192 ret = ClientTransAddUdpChannel(channel);
193 EXPECT_TRUE(ret == SOFTBUS_OK);
194 }
195
196 /**
197 * @tc.name: TransFileListenerTest001
198 * @tc.desc: trans file listener init.
199 * @tc.type: FUNC
200 * @tc.require:
201 */
202 HWTEST_F(TransSdkFileTest, TransFileListenerTest001, TestSize.Level0)
203 {
204 TransFileDeinit();
205
206 int32_t ret = TransFileInit();
207 EXPECT_TRUE(ret == SOFTBUS_OK);
208
209 ret = TransFileInit();
210 EXPECT_TRUE(ret == SOFTBUS_OK);
211
212 TransFileDeinit();
213 TransFileDeinit();
214 }
215
216 /**
217 * @tc.name: TransFileListenerTest002
218 * @tc.desc: trans set file receive listener by sessionName.
219 * @tc.type: FUNC
220 * @tc.require:
221 */
222 HWTEST_F(TransSdkFileTest, TransFileListenerTest002, TestSize.Level0)
223 {
224 int32_t ret = TransFileInit();
225 EXPECT_TRUE(ret == SOFTBUS_OK);
226 const char* rootDir = "rootDir";
227 const char* sessionName = "file receive";
228 ret = TransSetFileReceiveListener(sessionName, &g_fileRecvListener, rootDir);
229 EXPECT_TRUE(ret == SOFTBUS_OK);
230
231 ret = TransSetFileReceiveListener(sessionName, &g_fileRecvListener, rootDir);
232 EXPECT_TRUE(ret == SOFTBUS_OK);
233
234 TransDeleteFileListener(sessionName);
235 TransFileDeinit();
236
237 ret = TransSetFileReceiveListener(sessionName, &g_fileRecvListener, rootDir);
238 EXPECT_TRUE(ret == SOFTBUS_TRANS_FILE_LISTENER_NOT_INIT);
239
240 TransFileDeinit();
241 }
242
243 /**
244 * @tc.name: TransFileListenerTest003
245 * @tc.desc: trans delete file listener by sessionName.
246 * @tc.type: FUNC
247 * @tc.require:
248 */
249 HWTEST_F(TransSdkFileTest, TransFileListenerTest003, TestSize.Level0)
250 {
251 int32_t ret = TransFileInit();
252 EXPECT_TRUE(ret == SOFTBUS_OK);
253 const char* rootDir = "rootDir";
254 const char* sessionName = "file receive";
255 const char* inValidName = "invald file receive";
256 TransDeleteFileListener(NULL);
257
258 ret = TransSetFileReceiveListener(sessionName, &g_fileRecvListener, rootDir);
259 EXPECT_TRUE(ret == SOFTBUS_OK);
260 TransDeleteFileListener(inValidName);
261
262 TransDeleteFileListener(sessionName);
263 TransFileDeinit();
264
265 TransDeleteFileListener(sessionName);
266 TransFileDeinit();
267 }
268
269 /**
270 * @tc.name: TransFileListenerTest004
271 * @tc.desc: trans set file send listener by sessionName.
272 * @tc.type: FUNC
273 * @tc.require:
274 */
275 HWTEST_F(TransSdkFileTest, TransFileListenerTest004, TestSize.Level0)
276 {
277 int32_t ret = TransFileInit();
278 EXPECT_TRUE(ret == SOFTBUS_OK);
279 const char* sessionName = "file send";
280 ret = TransSetFileSendListener(sessionName, &g_fileSendListener);
281 EXPECT_TRUE(ret == SOFTBUS_OK);
282
283 ret = TransSetFileSendListener(sessionName, &g_fileSendListener);
284 EXPECT_TRUE(ret == SOFTBUS_OK);
285
286 TransDeleteFileListener(sessionName);
287 TransFileDeinit();
288
289 ret = TransSetFileSendListener(sessionName, &g_fileSendListener);
290 EXPECT_TRUE(ret != SOFTBUS_OK);
291 }
292
293 /**
294 * @tc.name: TransFileListenerTest005
295 * @tc.desc: trans get file listener by sessionName.
296 * @tc.type: FUNC
297 * @tc.require:
298 */
299 HWTEST_F(TransSdkFileTest, TransFileListenerTest005, TestSize.Level0)
300 {
301 int32_t ret = TransFileInit();
302 EXPECT_TRUE(ret == SOFTBUS_OK);
303 const char* rootDir = "rootDir";
304 const char* sessionName = "file receive";
305 const char* inValidName = "invald file receive";
306 FileListener* fileListener = (FileListener *)SoftBusCalloc(sizeof(FileListener));
307 if (fileListener == NULL) {
308 return;
309 }
310 ret = TransSetFileReceiveListener(sessionName, &g_fileRecvListener, rootDir);
311 EXPECT_TRUE(ret == SOFTBUS_OK);
312
313 ret = TransSetFileSendListener(sessionName, &g_fileSendListener);
314 EXPECT_TRUE(ret == SOFTBUS_OK);
315
316 ret = TransGetFileListener(inValidName, fileListener);
317 EXPECT_TRUE(ret != SOFTBUS_OK);
318
319 ret = TransGetFileListener(sessionName, fileListener);
320 EXPECT_TRUE(ret == SOFTBUS_OK);
321 TransDeleteFileListener(sessionName);
322 TransFileDeinit();
323
324 ret = TransGetFileListener(sessionName, fileListener);
325 EXPECT_TRUE(ret != SOFTBUS_OK);
326 SoftBusFree(fileListener);
327 }
328
329 /**
330 * @tc.name: TransFileTest001
331 * @tc.desc: trans register file callback.
332 * @tc.type: FUNC
333 * @tc.require:
334 */
335 HWTEST_F(TransSdkFileTest, TransFileTest001, TestSize.Level0)
336 {
337 IClientSessionCallBack *cb = GetClientSessionCb();
338 int32_t ret = ClientTransUdpMgrInit(cb);
339 EXPECT_TRUE(ret == SOFTBUS_OK);
340
341 UdpChannelMgrCb *fileCb = NULL;
342 RegisterFileCb(NULL);
343 RegisterFileCb(fileCb);
344
345 ClientTransUdpMgrDeinit();
346 }
347
348 /**
349 * @tc.name: TransFileTest002
350 * @tc.desc: trans open file channel.
351 * @tc.type: FUNC
352 * @tc.require:
353 */
354 HWTEST_F(TransSdkFileTest, TransFileTest002, TestSize.Level0)
355 {
356 IClientSessionCallBack *cb = GetClientSessionCb();
357 int32_t ret = ClientTransUdpMgrInit(cb);
358 EXPECT_TRUE(ret == SOFTBUS_OK);
359 ret = TransFileInit();
360 EXPECT_TRUE(ret == SOFTBUS_OK);
361 const char* sessionName = "file send";
362 ChannelInfo *channelInfo = (ChannelInfo *)SoftBusCalloc(sizeof(ChannelInfo));
363 if (channelInfo == NULL) {
364 return;
365 }
366 UdpChannel *channel = TransAddChannelTest();
367 int32_t filePort = 22;
368
369 ret = ClientTransAddUdpChannel(channel);
370 EXPECT_TRUE(ret == SOFTBUS_OK);
371
372 ret = TransSetFileSendListener(sessionName, &g_fileSendListener);
373 EXPECT_TRUE(ret == SOFTBUS_OK);
374
375 ret = TransOnFileChannelOpened(sessionName, channelInfo, NULL);
376 EXPECT_TRUE(ret != SOFTBUS_OK);
377
378 ret = TransOnFileChannelOpened(sessionName, channelInfo, &filePort);
379 EXPECT_TRUE(ret != SOFTBUS_OK);
380
381 (void)strcpy_s(channelInfo->myIp, strlen("127.0.0.5") + 1, "127.0.0.5");
382 (void)strcpy_s(channelInfo->sessionKey, strlen("session key") + 1, "session key");
383
384 ret = TransOnFileChannelOpened(sessionName, channelInfo, &filePort);
385 EXPECT_TRUE(ret != SOFTBUS_OK);
386
387 channelInfo->isServer = false;
388 ret = TransOnFileChannelOpened(sessionName, channelInfo, &filePort);
389 EXPECT_TRUE(ret != SOFTBUS_OK);
390 ClientTransUdpMgrDeinit();
391 }
392
393 /**
394 * @tc.name: TransFileTest003
395 * @tc.desc: trans open file channel use diff param.
396 * @tc.type: FUNC
397 * @tc.require:
398 */
399 HWTEST_F(TransSdkFileTest, TransFileTest003, TestSize.Level0)
400 {
401 IClientSessionCallBack *cb = GetClientSessionCb();
402 (void)ClientTransUdpMgrInit(cb);
403 (void)TransFileInit();
404 IFileSendListener *sendListener = (IFileSendListener *)SoftBusCalloc(sizeof(IFileSendListener));
405 if (sendListener == NULL) {
406 return;
407 }
408 int32_t filePort = 22;
409 ChannelInfo *channelInfo = TransAddChannleInfoTest();
410 UdpChannel *channel = TransAddChannelTest();
411 DFileMsg *msgData = {};
412 DFileMsgType msgType = DFILE_ON_BIND;
413 FileSendListener(channel->dfileId, msgType, msgData);
414 int32_t ret = ClientTransAddUdpChannel(channel);
415 EXPECT_TRUE(ret == SOFTBUS_OK);
416
417 ret = TransSetFileSendListener(g_mySessionName, sendListener);
418 EXPECT_TRUE(ret == SOFTBUS_OK);
419
420 ret = TransOnFileChannelOpened(g_mySessionName, channelInfo, &filePort);
421 EXPECT_TRUE(ret != SOFTBUS_OK);
422
423 TransDeleteFileListener(g_mySessionName);
424 TransFileDeinit();
425 ClientTransUdpMgrDeinit();
426 }
427
428 /**
429 * @tc.name: TransFileTest004
430 * @tc.desc: trans file send listener use diff param.
431 * @tc.type: FUNC
432 * @tc.require:
433 */
434 HWTEST_F(TransSdkFileTest, TransFileTest004, TestSize.Level0)
435 {
436 int32_t ret = TransFileInit();
437 EXPECT_TRUE(ret == SOFTBUS_OK);
438 DFileMsgType msgType = DFILE_ON_CONNECT_SUCCESS;
439 DFileMsg msgData = {};
440 UdpChannel *channel = (UdpChannel*)SoftBusCalloc(sizeof(UdpChannel));
441 ASSERT_TRUE(channel != nullptr);
442 GenerateAndAddUdpChannel(channel);
443 FileSendListener(channel->dfileId, msgType, &msgData);
444
445 msgData.rate = 1;
446 FileSendListener(channel->dfileId, msgType, &msgData);
447
448 msgType = DFILE_ON_BIND;
449 FileSendListener(channel->dfileId, msgType, &msgData);
450
451 msgType = DFILE_ON_SESSION_IN_PROGRESS;
452 FileSendListener(channel->dfileId, msgType, &msgData);
453
454 msgType = DFILE_ON_SESSION_TRANSFER_RATE;
455 FileSendListener(channel->dfileId, msgType, &msgData);
456
457 ret = TransSetFileSendListener(channel->info.mySessionName, &g_fileSendListener);
458 EXPECT_TRUE(ret == SOFTBUS_OK);
459
460 FileSendListener(channel->dfileId, msgType, &msgData);
461
462 msgType = DFILE_ON_FILE_SEND_SUCCESS;
463 FileSendListener(channel->dfileId, msgType, &msgData);
464
465 msgType = DFILE_ON_FILE_SEND_FAIL;
466 FileSendListener(channel->dfileId, msgType, &msgData);
467
468 msgType = DFILE_ON_TRANS_IN_PROGRESS;
469 FileSendListener(channel->dfileId, msgType, &msgData);
470
471 msgType = DFILE_ON_SESSION_TRANSFER_RATE;
472 FileSendListener(channel->dfileId, msgType, &msgData);
473
474 msgType = DFILE_ON_CONNECT_FAIL;
475 FileSendListener(channel->dfileId, msgType, &msgData);
476
477 msgType = DFILE_ON_FATAL_ERROR;
478 FileSendListener(channel->dfileId, msgType, &msgData);
479
480 TransDeleteFileListener(channel->info.mySessionName);
481 TransFileDeinit();
482 ClientTransUdpMgrDeinit();
483 }
484
485 /**
486 * @tc.name: TransFileTest005
487 * @tc.desc: trans file recv listener use diff param.
488 * @tc.type: FUNC
489 * @tc.require:
490 */
491 HWTEST_F(TransSdkFileTest, TransFileTest005, TestSize.Level0)
492 {
493 int32_t ret = TransFileInit();
494 EXPECT_TRUE(ret == SOFTBUS_OK);
495 DFileMsgType msgType = DFILE_ON_CONNECT_SUCCESS;
496 DFileMsg msgData = {};
497 UdpChannel *channel = (UdpChannel*)SoftBusCalloc(sizeof(UdpChannel));
498 ASSERT_TRUE(channel != nullptr);
499 GenerateAndAddUdpChannel(channel);
500 FileReceiveListener(channel->dfileId, msgType, &msgData);
501
502 msgData.rate = 1;
503 FileReceiveListener(channel->dfileId, msgType, &msgData);
504
505 string rootDir = "rootDir";
506 ret = TransSetFileReceiveListener(channel->info.mySessionName, &g_fileRecvListener, rootDir.c_str());
507 EXPECT_TRUE(ret == SOFTBUS_OK);
508
509 msgType = DFILE_ON_FILE_LIST_RECEIVED;
510 FileReceiveListener(channel->dfileId, msgType, &msgData);
511
512 msgType = DFILE_ON_FILE_RECEIVE_SUCCESS;
513 FileReceiveListener(channel->dfileId, msgType, &msgData);
514
515 msgType = DFILE_ON_TRANS_IN_PROGRESS;
516 FileReceiveListener(channel->dfileId, msgType, &msgData);
517
518 msgType = DFILE_ON_FILE_RECEIVE_FAIL;
519 FileReceiveListener(channel->dfileId, msgType, &msgData);
520
521 msgType = DFILE_ON_CONNECT_SUCCESS;
522 FileReceiveListener(channel->dfileId, msgType, &msgData);
523
524 msgType = DFILE_ON_CONNECT_FAIL;
525 FileReceiveListener(channel->dfileId, msgType, &msgData);
526
527 msgType = DFILE_ON_FATAL_ERROR;
528 FileReceiveListener(channel->dfileId, msgType, &msgData);
529
530 TransDeleteFileListener(channel->info.mySessionName);
531 TransFileDeinit();
532 ClientTransUdpMgrDeinit();
533 }
534
535 /**
536 * @tc.name: TransFileTest006
537 * @tc.desc: trans file channel open use diff param.
538 * @tc.type: FUNC
539 * @tc.require:
540 */
541 HWTEST_F(TransSdkFileTest, TransFileTest006, TestSize.Level0)
542 {
543 IClientSessionCallBack *cb = GetClientSessionCb();
544 int32_t ret = ClientTransUdpMgrInit(cb);
545 EXPECT_TRUE(ret == SOFTBUS_OK);
546 ret = TransFileInit();
547 EXPECT_TRUE(ret == SOFTBUS_OK);
548 const char* sessionName = "file send";
549 IFileSendListener *sendListener;
550 ChannelInfo *channelInfo = (ChannelInfo *)SoftBusCalloc(sizeof(ChannelInfo));
551 if (channelInfo == NULL) {
552 return;
553 }
554 UdpChannel *channel = TransAddChannelTest();
555 int32_t filePort = 22;
556
557 ret = ClientTransAddUdpChannel(channel);
558 EXPECT_TRUE(ret == SOFTBUS_OK);
559
560 ret = TransSetFileSendListener(sessionName, sendListener);
561 EXPECT_TRUE(ret != SOFTBUS_OK);
562
563 ret = TransOnFileChannelOpened(sessionName, channelInfo, NULL);
564 EXPECT_TRUE(ret != SOFTBUS_OK);
565
566 ret = TransOnFileChannelOpened(sessionName, channelInfo, &filePort);
567 EXPECT_TRUE(ret != SOFTBUS_OK);
568
569 (void)strcpy_s(channelInfo->myIp, strlen("127.0.0.5") + 1, "127.0.0.5");
570 (void)strcpy_s(channelInfo->sessionKey, strlen("session key") + 1, "session key");
571
572 ret = TransOnFileChannelOpened(sessionName, channelInfo, &filePort);
573 EXPECT_TRUE(ret != SOFTBUS_OK);
574
575 channelInfo->isServer = false;
576 ret = TransOnFileChannelOpened(sessionName, channelInfo, &filePort);
577 EXPECT_TRUE(ret != SOFTBUS_OK);
578 ClientTransUdpMgrDeinit();
579 }
580
581 /**
582 * @tc.name: TransFileTest007
583 * @tc.desc: trans file channel use wrong param.
584 * @tc.type: FUNC
585 * @tc.require:
586 */
587 HWTEST_F(TransSdkFileTest, TransFileTest007, TestSize.Level0)
588 {
589 IClientSessionCallBack *cb = GetClientSessionCb();
590 (void)ClientTransUdpMgrInit(cb);
591 (void)TransFileInit();
592 IFileSendListener *sendListener = (IFileSendListener *)SoftBusCalloc(sizeof(IFileSendListener));
593 if (sendListener == NULL) {
594 return;
595 };
596 int32_t filePort = 22;
597 ChannelInfo *channelInfo = TransAddChannleInfoTest();
598 UdpChannel *channel = TransAddChannelTest();
599 DFileMsg *msgData = {};
600 DFileMsgType msgType = DFILE_ON_BIND;
601 FileSendListener(channel->dfileId, msgType, msgData);
602
603 int32_t ret = ClientTransAddUdpChannel(channel);
604 EXPECT_TRUE(ret == SOFTBUS_OK);
605
606 ret = TransSetFileSendListener(g_mySessionName, sendListener);
607 EXPECT_TRUE(ret == SOFTBUS_OK);
608
609 ret = TransOnFileChannelOpened(g_mySessionName, channelInfo, &filePort);
610 EXPECT_TRUE(ret != SOFTBUS_OK);
611
612 TransCloseFileChannel(channel->dfileId);
613
614 TransDeleteFileListener(g_mySessionName);
615 TransFileDeinit();
616 ClientTransUdpMgrDeinit();
617 }
618
619 /**
620 * @tc.name: TransFileTest008
621 * @tc.desc: trans file send use diff param.
622 * @tc.type: FUNC
623 * @tc.require:
624 */
625 HWTEST_F(TransSdkFileTest, TransFileTest008, TestSize.Level0)
626 {
627 int32_t sessionId = 0;
628 const char *sFileList = nullptr;
629 const char *dFileList = nullptr;
630 const char *fileList = "/file not null list/";
631 uint32_t fileCnt = 0;
632 int32_t ret = TransSendFile(sessionId, &sFileList, &dFileList, fileCnt);
633 EXPECT_TRUE(ret != SOFTBUS_OK);
634
635 ret = TransSendFile(sessionId, &fileList, &dFileList, fileCnt);
636 EXPECT_TRUE(ret != SOFTBUS_OK);
637 }
638
639 /**
640 * @tc.name: TransFileTest009
641 * @tc.desc: trans set reuse addr.
642 * @tc.type: FUNC
643 * @tc.require:
644 */
645 HWTEST_F(TransSdkFileTest, TransFileTest009, TestSize.Level0)
646 {
647 int fd = socket(AF_INET, SOCK_STREAM, 0);
648 int on = 65536;
649 int ret = SetReuseAddr(fd, on);
650 EXPECT_TRUE(ret == SOFTBUS_OK);
651
652 ret = SetReuseAddr(0, on);
653 EXPECT_TRUE(ret != SOFTBUS_OK);
654 }
655
656 /**
657 * @tc.name: TransFileTest010
658 * @tc.desc: trans set reuse port.
659 * @tc.type: FUNC
660 * @tc.require:
661 */
662 HWTEST_F(TransSdkFileTest, TransFileTest010, TestSize.Level0)
663 {
664 int fd = socket(AF_INET, SOCK_STREAM, 0);
665 int on = 65536;
666 int ret = SetReusePort(fd, on);
667 EXPECT_TRUE(ret == SOFTBUS_OK);
668
669 ret = SetReusePort(0, on);
670 EXPECT_TRUE(ret != SOFTBUS_OK);
671 }
672
673 /**
674 * @tc.name: TransFileTest011
675 * @tc.desc: trans open tcp server.
676 * @tc.type: FUNC
677 * @tc.require:
678 */
679 HWTEST_F(TransSdkFileTest, TransFileTest011, TestSize.Level0)
680 {
681 int port = 5683;
682 int ret = OpenTcpServer("127.0.0.1", port);
683 EXPECT_TRUE(ret != SOFTBUS_ERR);
684
685 ret = OpenTcpServer("280567565", port);
686 EXPECT_TRUE(ret == SOFTBUS_ERR);
687
688 ret = OpenTcpServer("127.0.0.1", 0);
689 EXPECT_TRUE(ret != SOFTBUS_OK);
690 }
691
692 /**
693 * @tc.name: TransFileTest012
694 * @tc.desc: trans start nstackx file at server.
695 * @tc.type: FUNC
696 * @tc.require:
697 */
698 HWTEST_F(TransSdkFileTest, TransFileTest012, TestSize.Level0)
699 {
700 uint8_t key = 215;
701 uint32_t keyLen = 8;
702 int32_t filePort = 25;
703 int32_t ret = StartNStackXDFileServer(NULL, &key, keyLen, g_fileMsgRecviver, &filePort);
704 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
705
706 ret = StartNStackXDFileServer("127.0.0.1", &key, keyLen, g_fileMsgRecviver, NULL);
707 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
708
709 ret = ConnInitSockets();
710 EXPECT_TRUE(ret == SOFTBUS_OK);
711 (void)StartNStackXDFileServer("127.0.0.1", &key, keyLen, g_fileMsgRecviver, &filePort);
712 ConnDeinitSockets();
713 }
714
715 /**
716 * @tc.name: TransFileTest013
717 * @tc.desc: trans start nstackx file at client.
718 * @tc.type: FUNC
719 * @tc.require:
720 */
721 HWTEST_F(TransSdkFileTest, TransFileTest013, TestSize.Level0)
722 {
723 uint8_t key = 215;
724 uint32_t keyLen = 8;
725 int32_t peerPort = 25;
726 int32_t ret = StartNStackXDFileClient(NULL, peerPort, &key, keyLen, g_fileMsgRecviver);
727 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
728 (void)StartNStackXDFileClient("127.0.0.1", peerPort, &key, keyLen, g_fileMsgRecviver);
729 }
730 }