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 <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.c"
25 #include "client_trans_udp_manager.h"
26 #include "file_adapter.c"
27 #include "nstackx_dfile.h"
28 #include "session.h"
29 #include "softbus_adapter_mem.h"
30 
31 using namespace testing::ext;
32 
33 namespace OHOS {
34 
35 const uint32_t g_keyLen = 10;
36 char g_mySessionName[] = {"my sessionName"};
37 char g_peerSessionName[] = {"peer sessionName"};
38 char g_peerDeviceId[] = {"127.0.0.4"};
39 char g_groupId[] = {"12345"};
40 char g_peerIp[] = {"11111"};
41 char g_sessionKey[] = {"123548246"};
42 char g_myIp[] = {"coms.132465"};
43 
TransAddChannelTest()44 UdpChannel *TransAddChannelTest()
45 {
46     UdpChannel *channel = (UdpChannel *)SoftBusCalloc(sizeof(UdpChannel));
47     if (channel == NULL) {
48         return nullptr;
49     }
50     channel->channelId = 1;
51     channel->dfileId = -1;
52     channel->channelId = 1;
53     channel->businessType = 1;
54     channel->isEnable = true;
55     channel->routeType = 1;
56     channel->info.isServer = 0;
57     channel->info.peerUid = 0;
58     channel->info.peerPid = 0;
59     (void)strcpy_s(channel->info.mySessionName, strlen("my sessionName")+1, "my sessionName");
60     (void)strcpy_s(channel->info.peerSessionName, strlen("peer sessionName")+1, "peer sessionName");
61     (void)strcpy_s(channel->info.peerDeviceId, strlen("127.0.0.4")+1, "127.0.0.4");
62     (void)strcpy_s(channel->info.groupId, strlen("12345")+1, "12345");
63     return channel;
64 }
TransAddChannleInfoTest()65 ChannelInfo *TransAddChannleInfoTest()
66 {
67     ChannelInfo *channelInfo = (ChannelInfo *)SoftBusCalloc(sizeof(ChannelInfo));
68     if (channelInfo == NULL) {
69         return nullptr;
70     }
71     channelInfo->channelId = 1;
72     channelInfo->channelType = 1;
73     channelInfo->businessType = 1;
74     channelInfo->fd = 1;
75     channelInfo->isServer = true;
76     channelInfo->isEnabled = true;
77     channelInfo->peerUid = 1;
78     channelInfo->peerPid = 1;
79     channelInfo->groupId = g_groupId;
80     channelInfo->keyLen = g_keyLen;
81     channelInfo->sessionKey = g_sessionKey;
82     channelInfo->peerSessionName = g_peerSessionName;
83     channelInfo->peerDeviceId = g_peerDeviceId;
84     channelInfo->myIp = g_myIp;
85     channelInfo->peerIp = g_peerIp;
86 
87     channelInfo->peerPort = 1;
88     channelInfo->routeType = 1;
89     channelInfo->streamType = 1;
90     channelInfo->encrypt = 1;
91     channelInfo->algorithm = 1;
92     channelInfo->crc = 1;
93     channelInfo->isUdpFile = false;
94     return channelInfo;
95 }
96 
97 class TransSdkFileTest : public testing::Test {
98 public:
TransSdkFileTest()99     TransSdkFileTest()
100     {}
~TransSdkFileTest()101     ~TransSdkFileTest()
102     {}
103     static void SetUpTestCase(void);
104     static void TearDownTestCase(void);
SetUp()105     void SetUp() override
106     {}
TearDown()107     void TearDown() override
108     {}
109 };
110 
SetUpTestCase(void)111 void TransSdkFileTest::SetUpTestCase(void)
112 {
113     IClientSessionCallBack *cb = GetClientSessionCb();
114     int32_t ret = ClientTransUdpMgrInit(cb);
115     EXPECT_EQ(ret, SOFTBUS_OK);
116     ret = TransFileInit();
117     EXPECT_EQ(ret, SOFTBUS_OK);
118 }
119 
TearDownTestCase(void)120 void TransSdkFileTest::TearDownTestCase(void)
121 {
122     ClientTransUdpMgrDeinit();
123     TransFileDeinit();
124 }
125 
OnFileTransErrorTest(int sessionId)126 void OnFileTransErrorTest(int sessionId)
127 {
128     std::cout << "OnFileTransError sessionId = %d\n" << sessionId << std::endl;
129 }
130 
OnReceiveFileStartedTest(int sessionId,const char * files,int fileCnt)131 int OnReceiveFileStartedTest(int sessionId, const char *files, int fileCnt)
132 {
133     std::cout << "File receive start sessionId = %d" << sessionId << std::endl;
134     return 0;
135 }
136 
OnReceiveFileFinishedTest(int sessionId,const char * files,int fileCnt)137 void OnReceiveFileFinishedTest(int sessionId, const char *files, int fileCnt)
138 {
139     std::cout << "File receive finished sessionId = %d\n" << sessionId << std::endl;
140 }
141 
OnReceiveFileProcessTest(int sessionId,const char * firstFile,uint64_t bytesUpload,uint64_t bytesTotal)142 int OnReceiveFileProcessTest(int sessionId, const char *firstFile, uint64_t bytesUpload, uint64_t bytesTotal)
143 {
144     std::cout << "File receive process sessionId = %d\n" << sessionId << std::endl;
145     return 0;
146 }
147 
OnSendFileProcessTest(int sessionId,uint64_t bytesUpload,uint64_t bytesTotal)148 int OnSendFileProcessTest(int sessionId, uint64_t bytesUpload, uint64_t bytesTotal)
149 {
150     std::cout << "send process id = " << sessionId << " upload = "
151         << bytesUpload << ", total = " << bytesTotal << std::endl;
152     return 0;
153 }
154 
OnSendFileFinishedTest(int sessionId,const char * firstFile)155 int OnSendFileFinishedTest(int sessionId, const char *firstFile)
156 {
157     std::cout << "send finished id = %d," << sessionId << "first file = %s." << firstFile << std::endl;
158     return 0;
159 }
160 
DFileMsgReceiverTest(int32_t sessionId,DFileMsgType msgType,const DFileMsg * msg)161 void DFileMsgReceiverTest(int32_t sessionId, DFileMsgType msgType, const DFileMsg *msg)
162 {
163     std::cout << "file receiver id = %d" << sessionId << std::endl;
164     return;
165 }
166 
167 
168 static IFileSendListener g_fileSendListener = {
169     .OnSendFileProcess = OnSendFileProcessTest,
170     .OnSendFileFinished = OnSendFileFinishedTest,
171     .OnFileTransError = OnFileTransErrorTest,
172 };
173 
174 static IFileReceiveListener g_fileRecvListener = {
175     .OnReceiveFileStarted = OnReceiveFileStartedTest,
176     .OnReceiveFileProcess = OnReceiveFileProcessTest,
177     .OnReceiveFileFinished = OnReceiveFileFinishedTest,
178     .OnFileTransError = OnFileTransErrorTest,
179 };
180 
181 static DFileMsgReceiver g_fileMsgRecviver = DFileMsgReceiverTest;
182 
GenerateAndAddUdpChannel(UdpChannel * channel)183 void GenerateAndAddUdpChannel(UdpChannel *channel)
184 {
185     IClientSessionCallBack *cb = GetClientSessionCb();
186     int32_t ret = ClientTransUdpMgrInit(cb);
187     EXPECT_EQ(ret, SOFTBUS_OK);
188     channel->channelId = 1;
189     channel->dfileId = 1;
190     channel->businessType = BUSINESS_TYPE_STREAM;
191     memcpy_s(channel->info.mySessionName, SESSION_NAME_SIZE_MAX,
192         "normal sessionName", strlen("normal sessionName"));
193     ret = ClientTransAddUdpChannel(channel);
194     EXPECT_EQ(ret, SOFTBUS_OK);
195 }
196 
SocketFileCallbackFuncTest(int32_t socket,FileEvent * event)197 static void SocketFileCallbackFuncTest(int32_t socket, FileEvent *event)
198 {
199     (void)socket;
200     (void)event;
201 }
202 
203 /**
204  * @tc.name: TransFileListenerTest001
205  * @tc.desc: trans file listener init.
206  * @tc.type: FUNC
207  * @tc.require:
208  */
209 HWTEST_F(TransSdkFileTest, TransFileListenerTest001, TestSize.Level0)
210 {
211     TransFileDeinit();
212 
213     int32_t ret = TransFileInit();
214     EXPECT_EQ(ret, SOFTBUS_OK);
215 
216     ret = TransFileInit();
217     EXPECT_EQ(ret, SOFTBUS_OK);
218 
219     TransFileDeinit();
220     TransFileDeinit();
221 }
222 
223 /**
224  * @tc.name: TransFileListenerTest002
225  * @tc.desc: trans set file receive listener by sessionName.
226  * @tc.type: FUNC
227  * @tc.require:
228  */
229 HWTEST_F(TransSdkFileTest, TransFileListenerTest002, TestSize.Level0)
230 {
231     int32_t ret = TransFileInit();
232     EXPECT_EQ(ret, SOFTBUS_OK);
233     const char* rootDir = "rootDir";
234     const char* sessionName = "file receive";
235     ret = TransSetFileReceiveListener(sessionName, &g_fileRecvListener, rootDir);
236     EXPECT_EQ(ret, SOFTBUS_OK);
237 
238     ret = TransSetFileReceiveListener(sessionName, &g_fileRecvListener, rootDir);
239     EXPECT_EQ(ret, SOFTBUS_OK);
240 
241     TransDeleteFileListener(sessionName);
242     TransFileDeinit();
243 
244     ret = TransSetFileReceiveListener(sessionName, &g_fileRecvListener, rootDir);
245     EXPECT_EQ(ret, SOFTBUS_TRANS_FILE_LISTENER_NOT_INIT);
246 
247     TransFileDeinit();
248 }
249 
250 /**
251  * @tc.name: TransFileListenerTest003
252  * @tc.desc: trans delete file listener by sessionName.
253  * @tc.type: FUNC
254  * @tc.require:
255  */
256 HWTEST_F(TransSdkFileTest, TransFileListenerTest003, TestSize.Level0)
257 {
258     int32_t ret = TransFileInit();
259     EXPECT_EQ(ret, SOFTBUS_OK);
260     const char* rootDir = "rootDir";
261     const char* sessionName = "file receive";
262     const char* inValidName = "invald file receive";
263     TransDeleteFileListener(NULL);
264 
265     ret = TransSetFileReceiveListener(sessionName, &g_fileRecvListener, rootDir);
266     EXPECT_EQ(ret, SOFTBUS_OK);
267     TransDeleteFileListener(inValidName);
268 
269     TransDeleteFileListener(sessionName);
270     TransFileDeinit();
271 
272     TransDeleteFileListener(sessionName);
273     TransFileDeinit();
274 }
275 
276 /**
277  * @tc.name: TransFileListenerTest004
278  * @tc.desc: trans set file send listener by sessionName.
279  * @tc.type: FUNC
280  * @tc.require:
281  */
282 HWTEST_F(TransSdkFileTest, TransFileListenerTest004, TestSize.Level0)
283 {
284     int32_t ret = TransFileInit();
285     EXPECT_EQ(ret, SOFTBUS_OK);
286     const char* sessionName = "file send";
287     ret = TransSetFileSendListener(sessionName, &g_fileSendListener);
288     EXPECT_EQ(ret, SOFTBUS_OK);
289 
290     ret = TransSetFileSendListener(sessionName, &g_fileSendListener);
291     EXPECT_EQ(ret, SOFTBUS_OK);
292 
293     TransDeleteFileListener(sessionName);
294     TransFileDeinit();
295 
296     ret = TransSetFileSendListener(sessionName, &g_fileSendListener);
297     EXPECT_EQ(ret, SOFTBUS_TRANS_FILE_LISTENER_NOT_INIT);
298 }
299 
300 /**
301  * @tc.name: TransFileListenerTest005
302  * @tc.desc: trans get file listener by sessionName.
303  * @tc.type: FUNC
304  * @tc.require:
305  */
306 HWTEST_F(TransSdkFileTest, TransFileListenerTest005, TestSize.Level0)
307 {
308     int32_t ret = TransFileInit();
309     EXPECT_EQ(ret, SOFTBUS_OK);
310     const char* rootDir = "rootDir";
311     const char* sessionName = "file receive";
312     const char* inValidName = "invald file receive";
313     FileListener* fileListener = (FileListener *)SoftBusCalloc(sizeof(FileListener));
314     if (fileListener == NULL) {
315         return;
316     }
317     ret = TransSetFileReceiveListener(sessionName, &g_fileRecvListener, rootDir);
318     EXPECT_EQ(ret, SOFTBUS_OK);
319 
320     ret = TransSetFileSendListener(sessionName, &g_fileSendListener);
321     EXPECT_EQ(ret, SOFTBUS_OK);
322 
323     ret = TransGetFileListener(inValidName, fileListener);
324     EXPECT_EQ(ret, SOFTBUS_TRANS_NODE_NOT_FOUND);
325 
326     ret = TransGetFileListener(sessionName, fileListener);
327     EXPECT_EQ(ret, SOFTBUS_OK);
328     TransDeleteFileListener(sessionName);
329     TransFileDeinit();
330 
331     ret = TransGetFileListener(sessionName, fileListener);
332     EXPECT_EQ(ret, SOFTBUS_TRANS_FILE_LISTENER_NOT_INIT);
333     SoftBusFree(fileListener);
334 }
335 
336 /**
337  * @tc.name: TransFileTest001
338  * @tc.desc: trans register file callback.
339  * @tc.type: FUNC
340  * @tc.require:
341  */
342 HWTEST_F(TransSdkFileTest, TransFileTest001, TestSize.Level0)
343 {
344     IClientSessionCallBack *cb = GetClientSessionCb();
345     int32_t ret = ClientTransUdpMgrInit(cb);
346     EXPECT_EQ(ret, SOFTBUS_OK);
347 
348     UdpChannelMgrCb *fileCb = NULL;
349     RegisterFileCb(NULL);
350     RegisterFileCb(fileCb);
351 
352     ClientTransUdpMgrDeinit();
353 }
354 
355 /**
356  * @tc.name: TransFileTest002
357  * @tc.desc: trans open file channel.
358  * @tc.type: FUNC
359  * @tc.require:
360  */
361 HWTEST_F(TransSdkFileTest, TransFileTest002, TestSize.Level0)
362 {
363     IClientSessionCallBack *cb = GetClientSessionCb();
364     int32_t ret = ClientTransUdpMgrInit(cb);
365     EXPECT_EQ(ret, SOFTBUS_OK);
366     ret = TransFileInit();
367     EXPECT_EQ(ret, SOFTBUS_OK);
368     const char* sessionName = "file send";
369     ChannelInfo *channelInfo = (ChannelInfo *)SoftBusCalloc(sizeof(ChannelInfo));
370     if (channelInfo == NULL) {
371         return;
372     }
373     UdpChannel *channel = TransAddChannelTest();
374     int32_t filePort = 22;
375 
376     ret = ClientTransAddUdpChannel(channel);
377     EXPECT_EQ(ret, SOFTBUS_OK);
378 
379     ret = TransSetFileSendListener(sessionName, &g_fileSendListener);
380     EXPECT_EQ(ret, SOFTBUS_OK);
381 
382     ret = TransOnFileChannelOpened(sessionName, channelInfo, NULL);
383     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
384 
385     ret = TransOnFileChannelOpened(sessionName, channelInfo, &filePort);
386     EXPECT_EQ(ret, SOFTBUS_FILE_ERR);
387 
388     (void)strcpy_s(channelInfo->myIp, strlen("127.0.0.5") + 1, "127.0.0.5");
389     (void)strcpy_s(channelInfo->sessionKey, strlen("session key") + 1, "session key");
390 
391     ret = TransOnFileChannelOpened(sessionName, channelInfo, &filePort);
392     EXPECT_EQ(ret, SOFTBUS_FILE_ERR);
393 
394     channelInfo->isServer = false;
395     ret = TransOnFileChannelOpened(sessionName, channelInfo, &filePort);
396     EXPECT_EQ(ret, SOFTBUS_FILE_ERR);
397     ClientTransUdpMgrDeinit();
398 }
399 
400 /**
401  * @tc.name: TransFileTest003
402  * @tc.desc: trans open file channel use diff param.
403  * @tc.type: FUNC
404  * @tc.require:
405  */
406 HWTEST_F(TransSdkFileTest, TransFileTest003, TestSize.Level0)
407 {
408     IClientSessionCallBack *cb = GetClientSessionCb();
409     (void)ClientTransUdpMgrInit(cb);
410     (void)TransFileInit();
411     IFileSendListener *sendListener = (IFileSendListener *)SoftBusCalloc(sizeof(IFileSendListener));
412     if (sendListener == NULL) {
413         return;
414     }
415     int32_t filePort = 22;
416     ChannelInfo *channelInfo = TransAddChannleInfoTest();
417     UdpChannel *channel = TransAddChannelTest();
418     DFileMsg *msgData = {};
419     DFileMsgType msgType = DFILE_ON_BIND;
420     FileSendListener(channel->dfileId, msgType, msgData);
421     int32_t ret = ClientTransAddUdpChannel(channel);
422     EXPECT_EQ(ret, SOFTBUS_OK);
423 
424     ret = TransSetFileSendListener(g_mySessionName, sendListener);
425     EXPECT_EQ(ret, SOFTBUS_OK);
426 
427     ret = TransOnFileChannelOpened(g_mySessionName, channelInfo, &filePort);
428     EXPECT_EQ(ret, SOFTBUS_FILE_ERR);
429 
430     TransDeleteFileListener(g_mySessionName);
431     TransFileDeinit();
432     ClientTransUdpMgrDeinit();
433 }
434 
435 /**
436  * @tc.name: TransFileTest004
437  * @tc.desc: trans file send listener use diff param.
438  * @tc.type: FUNC
439  * @tc.require:
440  */
441 HWTEST_F(TransSdkFileTest, TransFileTest004, TestSize.Level0)
442 {
443     int32_t ret = TransFileInit();
444     EXPECT_EQ(ret, SOFTBUS_OK);
445     DFileMsgType msgType = DFILE_ON_CONNECT_SUCCESS;
446     DFileMsg msgData = {};
447     UdpChannel *channel = (UdpChannel*)SoftBusCalloc(sizeof(UdpChannel));
448     ASSERT_TRUE(channel != nullptr);
449     GenerateAndAddUdpChannel(channel);
450     FileSendListener(channel->dfileId, msgType, &msgData);
451 
452     msgData.rate = 1;
453     FileSendListener(channel->dfileId, msgType, &msgData);
454 
455     msgType = DFILE_ON_BIND;
456     FileSendListener(channel->dfileId, msgType, &msgData);
457 
458     msgType = DFILE_ON_SESSION_IN_PROGRESS;
459     FileSendListener(channel->dfileId, msgType, &msgData);
460 
461     msgType = DFILE_ON_SESSION_TRANSFER_RATE;
462     FileSendListener(channel->dfileId, msgType, &msgData);
463 
464     ret = TransSetFileSendListener(channel->info.mySessionName, &g_fileSendListener);
465     EXPECT_EQ(ret, SOFTBUS_OK);
466 
467     FileSendListener(channel->dfileId, msgType, &msgData);
468 
469     msgType = DFILE_ON_FILE_SEND_SUCCESS;
470     FileSendListener(channel->dfileId, msgType, &msgData);
471 
472     msgType = DFILE_ON_FILE_SEND_FAIL;
473     FileSendListener(channel->dfileId, msgType, &msgData);
474 
475     msgType = DFILE_ON_TRANS_IN_PROGRESS;
476     FileSendListener(channel->dfileId, msgType, &msgData);
477 
478     msgType = DFILE_ON_SESSION_TRANSFER_RATE;
479     FileSendListener(channel->dfileId, msgType, &msgData);
480 
481     msgType = DFILE_ON_CONNECT_FAIL;
482     FileSendListener(channel->dfileId, msgType, &msgData);
483 
484     msgType = DFILE_ON_FATAL_ERROR;
485     FileSendListener(channel->dfileId, msgType, &msgData);
486 
487     TransDeleteFileListener(channel->info.mySessionName);
488     TransFileDeinit();
489     ClientTransUdpMgrDeinit();
490 }
491 
492 /**
493  * @tc.name: TransFileTest005
494  * @tc.desc: trans file recv listener use diff param.
495  * @tc.type: FUNC
496  * @tc.require:
497  */
498 HWTEST_F(TransSdkFileTest, TransFileTest005, TestSize.Level0)
499 {
500     int32_t ret = TransFileInit();
501     EXPECT_EQ(ret, SOFTBUS_OK);
502     DFileMsgType msgType = DFILE_ON_CONNECT_SUCCESS;
503     DFileMsg msgData = {};
504     UdpChannel *channel = (UdpChannel*)SoftBusCalloc(sizeof(UdpChannel));
505     ASSERT_TRUE(channel != nullptr);
506     GenerateAndAddUdpChannel(channel);
507     FileReceiveListener(channel->dfileId, msgType, &msgData);
508 
509     msgData.rate = 1;
510     FileReceiveListener(channel->dfileId, msgType, &msgData);
511 
512     string rootDir = "rootDir";
513     ret = TransSetFileReceiveListener(channel->info.mySessionName, &g_fileRecvListener, rootDir.c_str());
514     EXPECT_EQ(ret, SOFTBUS_OK);
515 
516     msgType = DFILE_ON_FILE_LIST_RECEIVED;
517     FileReceiveListener(channel->dfileId, msgType, &msgData);
518 
519     msgType = DFILE_ON_FILE_RECEIVE_SUCCESS;
520     FileReceiveListener(channel->dfileId, msgType, &msgData);
521 
522     msgType = DFILE_ON_TRANS_IN_PROGRESS;
523     FileReceiveListener(channel->dfileId, msgType, &msgData);
524 
525     msgType = DFILE_ON_FILE_RECEIVE_FAIL;
526     FileReceiveListener(channel->dfileId, msgType, &msgData);
527 
528     msgType = DFILE_ON_CONNECT_SUCCESS;
529     FileReceiveListener(channel->dfileId, msgType, &msgData);
530 
531     msgType = DFILE_ON_CONNECT_FAIL;
532     FileReceiveListener(channel->dfileId, msgType, &msgData);
533 
534     msgType = DFILE_ON_FATAL_ERROR;
535     FileReceiveListener(channel->dfileId, msgType, &msgData);
536 
537     TransDeleteFileListener(channel->info.mySessionName);
538     TransFileDeinit();
539     ClientTransUdpMgrDeinit();
540 }
541 
542 /**
543  * @tc.name: TransFileTest006
544  * @tc.desc: trans file channel open use diff param.
545  * @tc.type: FUNC
546  * @tc.require:
547  */
548 HWTEST_F(TransSdkFileTest, TransFileTest006, TestSize.Level0)
549 {
550     IClientSessionCallBack *cb = GetClientSessionCb();
551     int32_t ret = ClientTransUdpMgrInit(cb);
552     EXPECT_EQ(ret, SOFTBUS_OK);
553     ret = TransFileInit();
554     EXPECT_EQ(ret, SOFTBUS_OK);
555     const char* sessionName = "file send";
556     IFileSendListener *sendListener;
557     ChannelInfo *channelInfo = (ChannelInfo *)SoftBusCalloc(sizeof(ChannelInfo));
558     if (channelInfo == NULL) {
559         return;
560     }
561     UdpChannel *channel = TransAddChannelTest();
562     int32_t filePort = 22;
563 
564     ret = ClientTransAddUdpChannel(channel);
565     EXPECT_EQ(ret, SOFTBUS_OK);
566 
567     ret = TransSetFileSendListener(sessionName, sendListener);
568     EXPECT_EQ(ret, SOFTBUS_MEM_ERR);
569 
570     ret = TransOnFileChannelOpened(sessionName, channelInfo, NULL);
571     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
572 
573     ret = TransOnFileChannelOpened(sessionName, channelInfo, &filePort);
574     EXPECT_EQ(ret, SOFTBUS_FILE_ERR);
575 
576     (void)strcpy_s(channelInfo->myIp, strlen("127.0.0.5") + 1, "127.0.0.5");
577     (void)strcpy_s(channelInfo->sessionKey, strlen("session key") + 1, "session key");
578 
579     ret = TransOnFileChannelOpened(sessionName, channelInfo, &filePort);
580     EXPECT_EQ(ret, SOFTBUS_FILE_ERR);
581 
582     channelInfo->isServer = false;
583     ret = TransOnFileChannelOpened(sessionName, channelInfo, &filePort);
584     EXPECT_EQ(ret, SOFTBUS_FILE_ERR);
585     ClientTransUdpMgrDeinit();
586 }
587 
588 /**
589  * @tc.name: TransFileTest007
590  * @tc.desc: trans file channel use wrong param.
591  * @tc.type: FUNC
592  * @tc.require:
593  */
594 HWTEST_F(TransSdkFileTest, TransFileTest007, TestSize.Level0)
595 {
596     IClientSessionCallBack *cb = GetClientSessionCb();
597     (void)ClientTransUdpMgrInit(cb);
598     (void)TransFileInit();
599     IFileSendListener *sendListener = (IFileSendListener *)SoftBusCalloc(sizeof(IFileSendListener));
600     if (sendListener == NULL) {
601         return;
602     };
603     int32_t filePort = 22;
604     ChannelInfo *channelInfo = TransAddChannleInfoTest();
605     UdpChannel *channel = TransAddChannelTest();
606     DFileMsg *msgData = {};
607     DFileMsgType msgType = DFILE_ON_BIND;
608     FileSendListener(channel->dfileId, msgType, msgData);
609 
610     int32_t ret = ClientTransAddUdpChannel(channel);
611     EXPECT_EQ(ret, SOFTBUS_OK);
612 
613     ret = TransSetFileSendListener(g_mySessionName, sendListener);
614     EXPECT_EQ(ret, SOFTBUS_OK);
615 
616     ret = TransOnFileChannelOpened(g_mySessionName, channelInfo, &filePort);
617     EXPECT_EQ(ret, SOFTBUS_FILE_ERR);
618 
619     TransCloseFileChannel(channel->dfileId);
620 
621     TransDeleteFileListener(g_mySessionName);
622     TransFileDeinit();
623     ClientTransUdpMgrDeinit();
624 }
625 
626 /**
627  * @tc.name: TransFileTest008
628  * @tc.desc: trans file send use diff param.
629  * @tc.type: FUNC
630  * @tc.require:
631  */
632 HWTEST_F(TransSdkFileTest, TransFileTest008, TestSize.Level0)
633 {
634     int32_t sessionId = 0;
635     const char *sFileList = nullptr;
636     const char *dFileList = nullptr;
637     const char *fileList = "/file not null list/";
638     uint32_t fileCnt = 0;
639     int32_t ret = TransSendFile(sessionId, &sFileList, &dFileList, fileCnt);
640     EXPECT_TRUE(ret);
641 
642     ret = TransSendFile(sessionId, &fileList, &dFileList, fileCnt);
643     EXPECT_TRUE(ret);
644 }
645 
646 /**
647  * @tc.name: TransFileTest010
648  * @tc.desc: trans set reuse port.
649  * @tc.type: FUNC
650  * @tc.require:
651  */
652 HWTEST_F(TransSdkFileTest, TransFileTest010, TestSize.Level0)
653 {
654     int fd = socket(AF_INET, SOCK_STREAM, 0);
655     int on = 65536;
656     int ret = SetReusePort(fd, on);
657     EXPECT_EQ(ret, SOFTBUS_OK);
658 
659     ret = SetReusePort(0, on);
660     EXPECT_EQ(ret, SOFTBUS_INVALID_FD);
661 }
662 
663 /**
664  * @tc.name: TransFileTest012
665  * @tc.desc: trans start nstackx file at server.
666  * @tc.type: FUNC
667  * @tc.require:
668  */
669 HWTEST_F(TransSdkFileTest, TransFileTest012, TestSize.Level0)
670 {
671     uint8_t key = 215;
672     uint32_t keyLen = 8;
673     int32_t filePort = 25;
674     int32_t ret = StartNStackXDFileServer(NULL, &key, keyLen, g_fileMsgRecviver, &filePort);
675     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
676 
677     ret = StartNStackXDFileServer("127.0.0.1", &key, keyLen, g_fileMsgRecviver, NULL);
678     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
679 
680     ret = ConnInitSockets();
681     EXPECT_EQ(ret, SOFTBUS_OK);
682     (void)StartNStackXDFileServer("127.0.0.1", &key, keyLen, g_fileMsgRecviver, &filePort);
683     ConnDeinitSockets();
684 }
685 
686 /**
687  * @tc.name: TransFileTest013
688  * @tc.desc: trans start nstackx file at client.
689  * @tc.type: FUNC
690  * @tc.require:
691  */
692 HWTEST_F(TransSdkFileTest, TransFileTest013, TestSize.Level0)
693 {
694     uint8_t key = 215;
695     uint32_t keyLen = 8;
696     int32_t peerPort = 25;
697     int32_t ret = StartNStackXDFileClient(NULL, peerPort, &key, keyLen, g_fileMsgRecviver);
698     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
699     (void)StartNStackXDFileClient("127.0.0.1", peerPort, &key, keyLen, g_fileMsgRecviver);
700 }
701 
702 /**
703  * @tc.name: TransFileTest014
704  * @tc.desc: trans register file callback of socket
705  * @tc.type: FUNC
706  * @tc.require:
707  */
708 HWTEST_F(TransSdkFileTest, TransFileTest014, TestSize.Level0)
709 {
710     int32_t ret = TransSetSocketFileListener(nullptr, nullptr, false);
711     ASSERT_EQ(ret, SOFTBUS_INVALID_PARAM);
712 
713     ret = TransSetSocketFileListener(g_mySessionName, nullptr, false);
714     ASSERT_EQ(ret, SOFTBUS_INVALID_PARAM);
715 
716     ret = TransSetSocketFileListener(nullptr, SocketFileCallbackFuncTest, false);
717     ASSERT_EQ(ret, SOFTBUS_INVALID_PARAM);
718 
719     ret = TransFileInit();
720     EXPECT_EQ(ret, SOFTBUS_OK);
721     ret = TransSetSocketFileListener(g_mySessionName, SocketFileCallbackFuncTest, false);
722     ASSERT_EQ(ret, SOFTBUS_OK);
723     TransFileDeinit();
724 }
725 
726 /**
727  * @tc.name: TransFileTest015
728  * @tc.desc: trans add new file callback of socket
729  * @tc.type: FUNC
730  * @tc.require:
731  */
732 HWTEST_F(TransSdkFileTest, TransFileTest015, TestSize.Level0)
733 {
734     int32_t ret = TransFileInit();
735     EXPECT_EQ(ret, SOFTBUS_OK);
736     ret = TransAddNewSocketFileListener(nullptr, nullptr, false);
737     ASSERT_EQ(ret, SOFTBUS_INVALID_PARAM);
738 
739     ret = TransAddNewSocketFileListener(g_mySessionName, nullptr, false);
740     ASSERT_EQ(ret, SOFTBUS_INVALID_PARAM);
741 
742     ret = TransAddNewSocketFileListener(nullptr, SocketFileCallbackFuncTest, false);
743     ASSERT_EQ(ret, SOFTBUS_INVALID_PARAM);
744 
745     ret = TransAddNewSocketFileListener(g_mySessionName, SocketFileCallbackFuncTest, false);
746     ASSERT_EQ(ret, SOFTBUS_OK);
747     TransFileDeinit();
748 }
749 
750 /**
751  * @tc.name: FreeFileStatusListTest001
752  * @tc.desc: test free file status list
753  * @tc.type: FUNC
754  * @tc.require:
755  */
756 HWTEST_F(TransSdkFileTest, FreeFileStatusListTest001, TestSize.Level0)
757 {
758     FileEvent event;
759     event.statusList.completedList.fileCnt = 1;
760     event.statusList.notCompletedList.fileCnt = 1;
761     event.statusList.notStartedList.fileCnt = 1;
762     event.statusList.completedList.files =
763         (char **)SoftBusCalloc(event.statusList.completedList.fileCnt * sizeof(char *));
764     event.statusList.notCompletedList.files =
765         (char **)SoftBusCalloc(event.statusList.notCompletedList.fileCnt * sizeof(char *));
766     event.statusList.notStartedList.files =
767         (char **)SoftBusCalloc(event.statusList.notStartedList.fileCnt * sizeof(char *));
768 
769     FreeFileStatusList(&event);
770 
771     ASSERT_EQ(event.statusList.completedList.files, nullptr);
772     ASSERT_EQ(event.statusList.notCompletedList.files, nullptr);
773     ASSERT_EQ(event.statusList.notStartedList.files, nullptr);
774     SoftBusFree(event.statusList.completedList.files);
775     SoftBusFree(event.statusList.notCompletedList.files);
776     SoftBusFree(event.statusList.notStartedList.files);
777 
778     FileEvent *event2 = nullptr;
779     FreeFileStatusList(event2);
780 }
781 
782 /**
783  * @tc.name: FreeFileStatusListTest002
784  * @tc.desc: test free file status list with null files
785  * @tc.type: FUNC
786  * @tc.require:
787  */
788 HWTEST_F(TransSdkFileTest, FreeFileStatusListTest002, TestSize.Level0)
789 {
790     FileEvent event;
791     event.statusList.completedList.files = nullptr;
792     event.statusList.notCompletedList.files = nullptr;
793     event.statusList.notStartedList.files = nullptr;
794 
795     FreeFileStatusList(&event);
796     ASSERT_EQ(event.statusList.completedList.files, nullptr);
797     ASSERT_EQ(event.statusList.notCompletedList.files, nullptr);
798     ASSERT_EQ(event.statusList.notStartedList.files, nullptr);
799 }
800 
801 /**
802  * @tc.name: FillFileStatusListTest001
803  * @tc.desc: test fill file status list
804  * @tc.type: FUNC
805  * @tc.require:
806  */
807 HWTEST_F(TransSdkFileTest, FillFileStatusListTest001, TestSize.Level0)
808 {
809     DFileMsg msgData;
810     FileEvent event;
811     msgData.clearPolicyFileList.fileNum = 3;
812     DFileFileInfo *fileInfo =
813         (DFileFileInfo *)SoftBusCalloc(msgData.clearPolicyFileList.fileNum * sizeof(DFileFileInfo));
814     fileInfo[0].stat = FILE_STAT_COMPLETE;
815     fileInfo[0].file = (char *)"file1";
816     fileInfo[1].stat = FILE_STAT_NOT_COMPLETE;
817     fileInfo[1].file = (char *)"file2";
818     fileInfo[2].stat = FILE_STAT_NOT_START;
819     fileInfo[2].file = (char *)"file3";
820     msgData.clearPolicyFileList.fileInfo = fileInfo;
821 
822     FillFileStatusList(&msgData, &event);
823 
824     // Check status list content
825     ASSERT_EQ(1, event.statusList.completedList.fileCnt);
826     ASSERT_STREQ("file1", event.statusList.completedList.files[0]);
827     ASSERT_EQ(1, event.statusList.notCompletedList.fileCnt);
828     ASSERT_STREQ("file2", event.statusList.notCompletedList.files[0]);
829     ASSERT_EQ(1, event.statusList.notStartedList.fileCnt);
830     ASSERT_STREQ("file3", event.statusList.notStartedList.files[0]);
831     SoftBusFree(fileInfo);
832 }
833 
834 /**
835  * @tc.name: FillFileStatusListTest002
836  * @tc.desc: test fill file status list
837  * @tc.type: FUNC
838  * @tc.require:
839  */
840 HWTEST_F(TransSdkFileTest, FillFileStatusListTest002, TestSize.Level0)
841 {
842     DFileMsg msgData;
843     FileEvent event;
844     msgData.clearPolicyFileList.fileNum = 0;
845 
846     FillFileStatusList(&msgData, &event);
847 
848     // Check status list content
849     ASSERT_EQ(nullptr, event.statusList.completedList.files);
850     ASSERT_EQ(0, event.statusList.completedList.fileCnt);
851     ASSERT_EQ(nullptr, event.statusList.notCompletedList.files);
852     ASSERT_EQ(0, event.statusList.notCompletedList.fileCnt);
853     ASSERT_EQ(nullptr, event.statusList.notStartedList.files);
854     ASSERT_EQ(0, event.statusList.notStartedList.fileCnt);
855 }
856 
857 /**
858  * @tc.name: FillFileStatusListTest003
859  * @tc.desc: test fill file status list
860  * @tc.type: FUNC
861  * @tc.require:
862  */
863 HWTEST_F(TransSdkFileTest, FillFileStatusListTest003, TestSize.Level0)
864 {
865     DFileMsg msgData;
866     FileEvent event;
867     msgData.clearPolicyFileList.fileNum = 3;
868     DFileFileInfo *fileInfo =
869         (DFileFileInfo *)SoftBusCalloc(msgData.clearPolicyFileList.fileNum * sizeof(DFileFileInfo));
870     fileInfo[0].stat = FILE_STAT_COMPLETE;
871     fileInfo[0].file = (char *)"file1";
872     fileInfo[1].stat = FILE_STAT_COMPLETE;
873     fileInfo[1].file = (char *)"file2";
874     fileInfo[2].stat = FILE_STAT_COMPLETE;
875     fileInfo[2].file = (char *)"file3";
876     msgData.clearPolicyFileList.fileInfo = fileInfo;
877 
878     FillFileStatusList(&msgData, &event);
879 
880     // Check status list content
881     ASSERT_EQ(3, event.statusList.completedList.fileCnt);
882     ASSERT_STREQ("file1", event.statusList.completedList.files[0]);
883     ASSERT_STREQ("file2", event.statusList.completedList.files[1]);
884     ASSERT_STREQ("file3", event.statusList.completedList.files[2]);
885     ASSERT_EQ(0, event.statusList.notCompletedList.fileCnt);
886     ASSERT_EQ(0, event.statusList.notStartedList.fileCnt);
887     SoftBusFree(fileInfo);
888 }
889 
MockSocketSendCallback(int32_t socket,FileEvent * event)890 void MockSocketSendCallback(int32_t socket, FileEvent *event)
891 {
892     (void)socket;
893     (void)event;
894 }
895 
MockSocketRecvCallback(int32_t socket,FileEvent * event)896 void MockSocketRecvCallback(int32_t socket, FileEvent *event)
897 {
898     (void)socket;
899     (void)event;
900 }
901 
InitDFileMsg(DFileMsg * msgData)902 void InitDFileMsg(DFileMsg *msgData)
903 {
904     msgData->fileList.files = nullptr;
905     msgData->fileList.fileNum = 0;
906     msgData->clearPolicyFileList.fileNum = 0;
907     msgData->clearPolicyFileList.fileInfo = nullptr;
908     msgData->errorCode = 0;
909     msgData->transferUpdate.bytesTransferred = 0;
910     msgData->transferUpdate.totalBytes = 0;
911     msgData->transferUpdate.transId = 0;
912     msgData->rate = 0;
913 }
914 
915 /**
916  * @tc.name: NotifySocketSendResultTest001
917  * @tc.desc: test notify socket send result
918  * @tc.type: FUNC
919  * @tc.require:
920  */
921 HWTEST_F(TransSdkFileTest, NotifySocketSendResultTest001, TestSize.Level0)
922 {
923     int32_t socket = 1;
924     DFileMsg msgData;
925     InitDFileMsg(&msgData);
926     FileListener listener;
927     listener.socketSendCallback = MockSocketSendCallback;
928     listener.socketRecvCallback = MockSocketRecvCallback;
929 
930     NotifySocketSendResult(socket, DFILE_ON_TRANS_IN_PROGRESS, &msgData, &listener);
931     NotifySocketSendResult(socket, DFILE_ON_FILE_SEND_SUCCESS, &msgData, &listener);
932     NotifySocketSendResult(socket, DFILE_ON_FILE_SEND_FAIL, &msgData, &listener);
933     NotifySocketSendResult(socket, DFILE_ON_CLEAR_POLICY_FILE_LIST, &msgData, &listener);
934     NotifySocketSendResult(socket, DFILE_ON_CONNECT_FAIL, &msgData, &listener);
935 
936     NotifySocketRecvResult(socket, DFILE_ON_FILE_LIST_RECEIVED, &msgData, &listener);
937     NotifySocketRecvResult(socket, DFILE_ON_TRANS_IN_PROGRESS, &msgData, &listener);
938     NotifySocketRecvResult(socket, DFILE_ON_FILE_RECEIVE_SUCCESS, &msgData, &listener);
939     NotifySocketRecvResult(socket, DFILE_ON_FILE_RECEIVE_FAIL, &msgData, &listener);
940     NotifySocketRecvResult(socket, DFILE_ON_CLEAR_POLICY_FILE_LIST, &msgData, &listener);
941     NotifySocketRecvResult(socket, DFILE_ON_CONNECT_FAIL, &msgData, &listener);
942 }
943 
944 /**
945  * @tc.name: FillFileEventErrorCodeTest
946  * @tc.desc: test fill file event error code
947  * @tc.type: FUNC
948  * @tc.require:
949  */
950 HWTEST_F(TransSdkFileTest, FillFileEventErrorCodeTest, TestSize.Level0)
951 {
952     DFileMsg msgData;
953     FileEvent event;
954 
955     msgData.errorCode = NSTACKX_EOK;
956     FillFileEventErrorCode(&msgData, &event);
957     ASSERT_EQ(SOFTBUS_OK, event.errorCode);
958 
959     msgData.errorCode = NSTACKX_EPERM;
960     FillFileEventErrorCode(&msgData, &event);
961     ASSERT_EQ(SOFTBUS_TRANS_FILE_PERMISSION_DENIED, event.errorCode);
962 
963     msgData.errorCode = NSTACKX_EDQUOT;
964     FillFileEventErrorCode(&msgData, &event);
965     ASSERT_EQ(SOFTBUS_TRANS_FILE_DISK_QUOTA_EXCEEDED, event.errorCode);
966 
967     msgData.errorCode = NSTACKX_ENOMEM;
968     FillFileEventErrorCode(&msgData, &event);
969     ASSERT_EQ(SOFTBUS_TRANS_FILE_NO_MEMORY, event.errorCode);
970 
971     msgData.errorCode = NSTACKX_ENETDOWN;
972     FillFileEventErrorCode(&msgData, &event);
973     ASSERT_EQ(SOFTBUS_TRANS_FILE_NETWORK_ERROR, event.errorCode);
974 
975     msgData.errorCode = NSTACKX_EEXIST;
976     FillFileEventErrorCode(&msgData, &event);
977     ASSERT_EQ(SOFTBUS_TRANS_FILE_EXISTED, event.errorCode);
978 
979     msgData.errorCode = NSTACKX_NOTSUPPORT;
980     FillFileEventErrorCode(&msgData, &event);
981     ASSERT_EQ(NSTACKX_NOTSUPPORT, event.errorCode);
982 }
983 }