1 /*
2 * Copyright (c) 2022-2025 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 #define TEST_SESSIONID 10
34 #define TEST_CHANNELID 1025
35
36 namespace OHOS {
37
38 const uint32_t g_keyLen = 10;
39 char g_mySessionName[] = {"my sessionName"};
40 char g_peerSessionName[] = {"peer sessionName"};
41 char g_peerDeviceId[] = {"127.0.0.4"};
42 char g_groupId[] = {"12345"};
43 char g_peerIp[] = {"11111"};
44 char g_sessionKey[] = {"123548246"};
45 char g_myIp[] = {"coms.132465"};
46
TransAddChannelTest()47 UdpChannel *TransAddChannelTest()
48 {
49 UdpChannel *channel = (UdpChannel *)SoftBusCalloc(sizeof(UdpChannel));
50 if (channel == nullptr) {
51 return nullptr;
52 }
53 channel->channelId = 1;
54 channel->dfileId = -1;
55 channel->channelId = 1;
56 channel->businessType = 1;
57 channel->isEnable = true;
58 channel->routeType = 1;
59 channel->info.isServer = 0;
60 channel->info.peerUid = 0;
61 channel->info.peerPid = 0;
62 (void)strcpy_s(channel->info.mySessionName, strlen("my sessionName")+1, "my sessionName");
63 (void)strcpy_s(channel->info.peerSessionName, strlen("peer sessionName")+1, "peer sessionName");
64 (void)strcpy_s(channel->info.peerDeviceId, strlen("127.0.0.4")+1, "127.0.0.4");
65 (void)strcpy_s(channel->info.groupId, strlen("12345")+1, "12345");
66 return channel;
67 }
TransAddChannleInfoTest()68 ChannelInfo *TransAddChannleInfoTest()
69 {
70 ChannelInfo *channelInfo = (ChannelInfo *)SoftBusCalloc(sizeof(ChannelInfo));
71 if (channelInfo == nullptr) {
72 return nullptr;
73 }
74 channelInfo->channelId = 1;
75 channelInfo->channelType = 1;
76 channelInfo->businessType = 1;
77 channelInfo->fd = 1;
78 channelInfo->isServer = true;
79 channelInfo->isEnabled = true;
80 channelInfo->peerUid = 1;
81 channelInfo->peerPid = 1;
82 channelInfo->groupId = g_groupId;
83 channelInfo->keyLen = g_keyLen;
84 channelInfo->sessionKey = g_sessionKey;
85 channelInfo->peerSessionName = g_peerSessionName;
86 channelInfo->peerDeviceId = g_peerDeviceId;
87 channelInfo->myIp = g_myIp;
88 channelInfo->peerIp = g_peerIp;
89
90 channelInfo->peerPort = 1;
91 channelInfo->routeType = 1;
92 channelInfo->streamType = 1;
93 channelInfo->encrypt = 1;
94 channelInfo->algorithm = 1;
95 channelInfo->crc = 1;
96 channelInfo->isUdpFile = false;
97 return channelInfo;
98 }
99
100 class TransSdkFileTest : public testing::Test {
101 public:
TransSdkFileTest()102 TransSdkFileTest()
103 {}
~TransSdkFileTest()104 ~TransSdkFileTest()
105 {}
106 static void SetUpTestCase(void);
107 static void TearDownTestCase(void);
SetUp()108 void SetUp() override
109 {}
TearDown()110 void TearDown() override
111 {}
112 };
113
SetUpTestCase(void)114 void TransSdkFileTest::SetUpTestCase(void)
115 {
116 IClientSessionCallBack *cb = GetClientSessionCb();
117 int32_t ret = ClientTransUdpMgrInit(cb);
118 EXPECT_EQ(ret, SOFTBUS_OK);
119 ret = TransFileInit();
120 EXPECT_EQ(ret, SOFTBUS_OK);
121 }
122
TearDownTestCase(void)123 void TransSdkFileTest::TearDownTestCase(void)
124 {
125 ClientTransUdpMgrDeinit();
126 TransFileDeinit();
127 }
128
OnFileTransErrorTest(int32_t sessionId)129 void OnFileTransErrorTest(int32_t sessionId)
130 {
131 std::cout << "OnFileTransError sessionId = %d\n" << sessionId << std::endl;
132 }
133
OnReceiveFileStartedTest(int32_t sessionId,const char * files,int32_t fileCnt)134 int32_t OnReceiveFileStartedTest(int32_t sessionId, const char *files, int32_t fileCnt)
135 {
136 std::cout << "File receive start sessionId = %d" << sessionId << std::endl;
137 return 0;
138 }
139
OnReceiveFileFinishedTest(int32_t sessionId,const char * files,int32_t fileCnt)140 void OnReceiveFileFinishedTest(int32_t sessionId, const char *files, int32_t fileCnt)
141 {
142 std::cout << "File receive finished sessionId = %d\n" << sessionId << std::endl;
143 }
144
OnReceiveFileProcessTest(int32_t sessionId,const char * firstFile,uint64_t bytesUpload,uint64_t bytesTotal)145 int32_t OnReceiveFileProcessTest(int32_t sessionId, const char *firstFile, uint64_t bytesUpload, uint64_t bytesTotal)
146 {
147 std::cout << "File receive process sessionId = %d\n" << sessionId << std::endl;
148 return 0;
149 }
150
OnSendFileProcessTest(int32_t sessionId,uint64_t bytesUpload,uint64_t bytesTotal)151 int32_t OnSendFileProcessTest(int32_t sessionId, uint64_t bytesUpload, uint64_t bytesTotal)
152 {
153 std::cout << "send process id = " << sessionId << " upload = "
154 << bytesUpload << ", total = " << bytesTotal << std::endl;
155 return 0;
156 }
157
OnSendFileFinishedTest(int32_t sessionId,const char * firstFile)158 int32_t OnSendFileFinishedTest(int32_t sessionId, const char *firstFile)
159 {
160 std::cout << "send finished id = %d," << sessionId << "first file = %s." << firstFile << std::endl;
161 return 0;
162 }
163
DFileMsgReceiverTest(int32_t sessionId,DFileMsgType msgType,const DFileMsg * msg)164 void DFileMsgReceiverTest(int32_t sessionId, DFileMsgType msgType, const DFileMsg *msg)
165 {
166 std::cout << "file receiver id = %d" << sessionId << std::endl;
167 return;
168 }
169
170
171 static IFileSendListener g_fileSendListener = {
172 .OnSendFileProcess = OnSendFileProcessTest,
173 .OnSendFileFinished = OnSendFileFinishedTest,
174 .OnFileTransError = OnFileTransErrorTest,
175 };
176
177 static IFileReceiveListener g_fileRecvListener = {
178 .OnReceiveFileStarted = OnReceiveFileStartedTest,
179 .OnReceiveFileProcess = OnReceiveFileProcessTest,
180 .OnReceiveFileFinished = OnReceiveFileFinishedTest,
181 .OnFileTransError = OnFileTransErrorTest,
182 };
183
184 static DFileMsgReceiver g_fileMsgRecviver = DFileMsgReceiverTest;
185
GenerateAndAddUdpChannel(UdpChannel * channel)186 void GenerateAndAddUdpChannel(UdpChannel *channel)
187 {
188 IClientSessionCallBack *cb = GetClientSessionCb();
189 int32_t ret = ClientTransUdpMgrInit(cb);
190 EXPECT_EQ(ret, SOFTBUS_OK);
191 channel->channelId = 1;
192 channel->dfileId = 1;
193 channel->businessType = BUSINESS_TYPE_STREAM;
194 memcpy_s(channel->info.mySessionName, SESSION_NAME_SIZE_MAX,
195 "normal sessionName", strlen("normal sessionName"));
196 ret = ClientTransAddUdpChannel(channel);
197 EXPECT_EQ(ret, SOFTBUS_OK);
198 }
199
SocketFileCallbackFuncTest(int32_t socket,FileEvent * event)200 static void SocketFileCallbackFuncTest(int32_t socket, FileEvent *event)
201 {
202 (void)socket;
203 (void)event;
204 }
205
206 /**
207 * @tc.name: TransFileListenerTest001
208 * @tc.desc: trans file listener init.
209 * @tc.type: FUNC
210 * @tc.require:
211 */
212 HWTEST_F(TransSdkFileTest, TransFileListenerTest001, TestSize.Level0)
213 {
214 TransFileDeinit();
215
216 int32_t ret = TransFileInit();
217 EXPECT_EQ(ret, SOFTBUS_OK);
218
219 ret = TransFileInit();
220 EXPECT_EQ(ret, SOFTBUS_OK);
221
222 TransFileDeinit();
223 TransFileDeinit();
224 }
225
226 /**
227 * @tc.name: TransFileListenerTest002
228 * @tc.desc: trans set file receive listener by sessionName.
229 * @tc.type: FUNC
230 * @tc.require:
231 */
232 HWTEST_F(TransSdkFileTest, TransFileListenerTest002, TestSize.Level0)
233 {
234 int32_t ret = TransFileInit();
235 EXPECT_EQ(ret, SOFTBUS_OK);
236 const char* rootDir = "rootDir";
237 const char* sessionName = "file receive";
238 ret = TransSetFileReceiveListener(sessionName, &g_fileRecvListener, rootDir);
239 EXPECT_EQ(ret, SOFTBUS_OK);
240
241 ret = TransSetFileReceiveListener(sessionName, &g_fileRecvListener, rootDir);
242 EXPECT_EQ(ret, SOFTBUS_OK);
243
244 TransDeleteFileListener(sessionName);
245 TransFileDeinit();
246
247 ret = TransSetFileReceiveListener(sessionName, &g_fileRecvListener, rootDir);
248 EXPECT_EQ(ret, SOFTBUS_TRANS_FILE_LISTENER_NOT_INIT);
249
250 TransFileDeinit();
251 }
252
253 /**
254 * @tc.name: TransFileListenerTest003
255 * @tc.desc: trans delete file listener by sessionName.
256 * @tc.type: FUNC
257 * @tc.require:
258 */
259 HWTEST_F(TransSdkFileTest, TransFileListenerTest003, TestSize.Level0)
260 {
261 int32_t ret = TransFileInit();
262 EXPECT_EQ(ret, SOFTBUS_OK);
263 const char* rootDir = "rootDir";
264 const char* sessionName = "file receive";
265 const char* inValidName = "invald file receive";
266 TransDeleteFileListener(nullptr);
267
268 ret = TransSetFileReceiveListener(sessionName, &g_fileRecvListener, rootDir);
269 EXPECT_EQ(ret, SOFTBUS_OK);
270 TransDeleteFileListener(inValidName);
271
272 TransDeleteFileListener(sessionName);
273 TransFileDeinit();
274
275 TransDeleteFileListener(sessionName);
276 TransFileDeinit();
277 }
278
279 /**
280 * @tc.name: TransFileListenerTest004
281 * @tc.desc: trans set file send listener by sessionName.
282 * @tc.type: FUNC
283 * @tc.require:
284 */
285 HWTEST_F(TransSdkFileTest, TransFileListenerTest004, TestSize.Level0)
286 {
287 int32_t ret = TransFileInit();
288 EXPECT_EQ(ret, SOFTBUS_OK);
289 const char* sessionName = "file send";
290 ret = TransSetFileSendListener(sessionName, &g_fileSendListener);
291 EXPECT_EQ(ret, SOFTBUS_OK);
292
293 ret = TransSetFileSendListener(sessionName, &g_fileSendListener);
294 EXPECT_EQ(ret, SOFTBUS_OK);
295
296 TransDeleteFileListener(sessionName);
297 TransFileDeinit();
298
299 ret = TransSetFileSendListener(sessionName, &g_fileSendListener);
300 EXPECT_EQ(ret, SOFTBUS_TRANS_FILE_LISTENER_NOT_INIT);
301 }
302
303 /**
304 * @tc.name: TransFileListenerTest005
305 * @tc.desc: trans get file listener by sessionName.
306 * @tc.type: FUNC
307 * @tc.require:
308 */
309 HWTEST_F(TransSdkFileTest, TransFileListenerTest005, TestSize.Level0)
310 {
311 int32_t ret = TransFileInit();
312 EXPECT_EQ(ret, SOFTBUS_OK);
313 const char* rootDir = "rootDir";
314 const char* sessionName = "file receive";
315 const char* inValidName = "invald file receive";
316 FileListener* fileListener = (FileListener *)SoftBusCalloc(sizeof(FileListener));
317 if (fileListener == nullptr) {
318 return;
319 }
320 ret = TransSetFileReceiveListener(sessionName, &g_fileRecvListener, rootDir);
321 EXPECT_EQ(ret, SOFTBUS_OK);
322
323 ret = TransSetFileSendListener(sessionName, &g_fileSendListener);
324 EXPECT_EQ(ret, SOFTBUS_OK);
325
326 ret = TransGetFileListener(nullptr, fileListener);
327 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
328
329 ret = TransGetFileListener(inValidName, nullptr);
330 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
331
332 ret = TransGetFileListener(inValidName, fileListener);
333 EXPECT_EQ(ret, SOFTBUS_TRANS_NODE_NOT_FOUND);
334
335 ret = TransGetFileListener(sessionName, fileListener);
336 EXPECT_EQ(ret, SOFTBUS_OK);
337 TransDeleteFileListener(sessionName);
338 TransFileDeinit();
339
340 ret = TransGetFileListener(sessionName, fileListener);
341 EXPECT_EQ(ret, SOFTBUS_TRANS_FILE_LISTENER_NOT_INIT);
342 SoftBusFree(fileListener);
343 }
344
345 /**
346 * @tc.name: TransFileTest001
347 * @tc.desc: trans register file callback.
348 * @tc.type: FUNC
349 * @tc.require:
350 */
351 HWTEST_F(TransSdkFileTest, TransFileTest001, TestSize.Level1)
352 {
353 IClientSessionCallBack *cb = GetClientSessionCb();
354 int32_t ret = ClientTransUdpMgrInit(cb);
355 EXPECT_EQ(ret, SOFTBUS_OK);
356
357 UdpChannelMgrCb *fileCb = nullptr;
358 RegisterFileCb(nullptr);
359 RegisterFileCb(fileCb);
360
361 ClientTransUdpMgrDeinit();
362 }
363
364 /**
365 * @tc.name: TransFileTest002
366 * @tc.desc: trans open file channel.
367 * @tc.type: FUNC
368 * @tc.require:
369 */
370 HWTEST_F(TransSdkFileTest, TransFileTest002, TestSize.Level1)
371 {
372 IClientSessionCallBack *cb = GetClientSessionCb();
373 int32_t ret = ClientTransUdpMgrInit(cb);
374 EXPECT_EQ(ret, SOFTBUS_OK);
375 ret = TransFileInit();
376 EXPECT_EQ(ret, SOFTBUS_OK);
377 const char* sessionName = "file send";
378 ChannelInfo *channelInfo = (ChannelInfo *)SoftBusCalloc(sizeof(ChannelInfo));
379 if (channelInfo == nullptr) {
380 return;
381 }
382 UdpChannel *channel = TransAddChannelTest();
383 int32_t filePort = 22;
384 SocketAccessInfo accessInfo = { 0 };
385 ret = ClientTransAddUdpChannel(channel);
386 EXPECT_EQ(ret, SOFTBUS_OK);
387
388 ret = TransSetFileSendListener(sessionName, &g_fileSendListener);
389 EXPECT_EQ(ret, SOFTBUS_OK);
390
391 ret = TransOnFileChannelOpened(sessionName, channelInfo, nullptr, &accessInfo);
392 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
393
394 ret = TransOnFileChannelOpened(sessionName, channelInfo, &filePort, &accessInfo);
395 EXPECT_EQ(ret, SOFTBUS_FILE_ERR);
396
397 (void)strcpy_s(channelInfo->myIp, strlen("127.0.0.5") + 1, "127.0.0.5");
398 (void)strcpy_s(channelInfo->sessionKey, strlen("session key") + 1, "session key");
399
400 ret = TransOnFileChannelOpened(sessionName, channelInfo, &filePort, &accessInfo);
401 EXPECT_EQ(ret, SOFTBUS_FILE_ERR);
402
403 channelInfo->isServer = false;
404 ret = TransOnFileChannelOpened(sessionName, channelInfo, &filePort, &accessInfo);
405 EXPECT_EQ(ret, SOFTBUS_FILE_ERR);
406 ClientTransUdpMgrDeinit();
407 }
408
409 /**
410 * @tc.name: TransFileTest003
411 * @tc.desc: trans open file channel use diff param.
412 * @tc.type: FUNC
413 * @tc.require:
414 */
415 HWTEST_F(TransSdkFileTest, TransFileTest003, TestSize.Level1)
416 {
417 IClientSessionCallBack *cb = GetClientSessionCb();
418 (void)ClientTransUdpMgrInit(cb);
419 (void)TransFileInit();
420 IFileSendListener *sendListener = (IFileSendListener *)SoftBusCalloc(sizeof(IFileSendListener));
421 if (sendListener == nullptr) {
422 return;
423 }
424 int32_t filePort = 22;
425 SocketAccessInfo accessInfo = { 0 };
426 ChannelInfo *channelInfo = TransAddChannleInfoTest();
427 UdpChannel *channel = TransAddChannelTest();
428 DFileMsg *msgData = {};
429 DFileMsgType msgType = DFILE_ON_BIND;
430 FileSendListener(channel->dfileId, msgType, msgData);
431 int32_t ret = ClientTransAddUdpChannel(channel);
432 EXPECT_EQ(ret, SOFTBUS_OK);
433
434 ret = TransSetFileSendListener(g_mySessionName, sendListener);
435 EXPECT_EQ(ret, SOFTBUS_OK);
436
437 ret = TransOnFileChannelOpened(g_mySessionName, channelInfo, &filePort, &accessInfo);
438 EXPECT_EQ(ret, SOFTBUS_FILE_ERR);
439
440 TransDeleteFileListener(g_mySessionName);
441 TransFileDeinit();
442 ClientTransUdpMgrDeinit();
443 }
444
445 /**
446 * @tc.name: TransFileTest004
447 * @tc.desc: trans file send listener use diff param.
448 * @tc.type: FUNC
449 * @tc.require:
450 */
451 HWTEST_F(TransSdkFileTest, TransFileTest004, TestSize.Level1)
452 {
453 int32_t ret = TransFileInit();
454 EXPECT_EQ(ret, SOFTBUS_OK);
455 DFileMsgType msgType = DFILE_ON_CONNECT_SUCCESS;
456 DFileMsg msgData = {};
457 UdpChannel *channel = (UdpChannel*)SoftBusCalloc(sizeof(UdpChannel));
458 ASSERT_TRUE(channel != nullptr);
459 GenerateAndAddUdpChannel(channel);
460 FileSendListener(channel->dfileId, msgType, &msgData);
461
462 msgData.rate = 1;
463 FileSendListener(channel->dfileId, msgType, &msgData);
464
465 msgType = DFILE_ON_BIND;
466 FileSendListener(channel->dfileId, msgType, &msgData);
467
468 msgType = DFILE_ON_SESSION_IN_PROGRESS;
469 FileSendListener(channel->dfileId, msgType, &msgData);
470
471 msgType = DFILE_ON_SESSION_TRANSFER_RATE;
472 FileSendListener(channel->dfileId, msgType, &msgData);
473
474 ret = TransSetFileSendListener(channel->info.mySessionName, &g_fileSendListener);
475 EXPECT_EQ(ret, SOFTBUS_OK);
476
477 FileSendListener(channel->dfileId, msgType, &msgData);
478
479 msgType = DFILE_ON_FILE_SEND_SUCCESS;
480 FileSendListener(channel->dfileId, msgType, &msgData);
481
482 msgType = DFILE_ON_FILE_SEND_FAIL;
483 FileSendListener(channel->dfileId, msgType, &msgData);
484
485 msgType = DFILE_ON_TRANS_IN_PROGRESS;
486 FileSendListener(channel->dfileId, msgType, &msgData);
487
488 msgType = DFILE_ON_SESSION_TRANSFER_RATE;
489 FileSendListener(channel->dfileId, msgType, &msgData);
490
491 msgType = DFILE_ON_CONNECT_FAIL;
492 FileSendListener(channel->dfileId, msgType, &msgData);
493
494 msgType = DFILE_ON_FATAL_ERROR;
495 FileSendListener(channel->dfileId, msgType, &msgData);
496
497 TransDeleteFileListener(channel->info.mySessionName);
498 TransFileDeinit();
499 ClientTransUdpMgrDeinit();
500 }
501
502 /**
503 * @tc.name: TransFileTest005
504 * @tc.desc: trans file recv listener use diff param.
505 * @tc.type: FUNC
506 * @tc.require:
507 */
508 HWTEST_F(TransSdkFileTest, TransFileTest005, TestSize.Level1)
509 {
510 int32_t ret = TransFileInit();
511 EXPECT_EQ(ret, SOFTBUS_OK);
512 DFileMsgType msgType = DFILE_ON_CONNECT_SUCCESS;
513 DFileMsg msgData = {};
514 UdpChannel *channel = (UdpChannel*)SoftBusCalloc(sizeof(UdpChannel));
515 ASSERT_TRUE(channel != nullptr);
516 GenerateAndAddUdpChannel(channel);
517 FileReceiveListener(channel->dfileId, msgType, &msgData);
518
519 msgData.rate = 1;
520 FileReceiveListener(channel->dfileId, msgType, &msgData);
521
522 string rootDir = "rootDir";
523 ret = TransSetFileReceiveListener(channel->info.mySessionName, &g_fileRecvListener, rootDir.c_str());
524 EXPECT_EQ(ret, SOFTBUS_OK);
525
526 msgType = DFILE_ON_FILE_LIST_RECEIVED;
527 FileReceiveListener(channel->dfileId, msgType, &msgData);
528
529 msgType = DFILE_ON_FILE_RECEIVE_SUCCESS;
530 FileReceiveListener(channel->dfileId, msgType, &msgData);
531
532 msgType = DFILE_ON_TRANS_IN_PROGRESS;
533 FileReceiveListener(channel->dfileId, msgType, &msgData);
534
535 msgType = DFILE_ON_FILE_RECEIVE_FAIL;
536 FileReceiveListener(channel->dfileId, msgType, &msgData);
537
538 msgType = DFILE_ON_CONNECT_SUCCESS;
539 FileReceiveListener(channel->dfileId, msgType, &msgData);
540
541 msgType = DFILE_ON_CONNECT_FAIL;
542 FileReceiveListener(channel->dfileId, msgType, &msgData);
543
544 msgType = DFILE_ON_FATAL_ERROR;
545 FileReceiveListener(channel->dfileId, msgType, &msgData);
546
547 TransDeleteFileListener(channel->info.mySessionName);
548 TransFileDeinit();
549 ClientTransUdpMgrDeinit();
550 }
551
552 /**
553 * @tc.name: TransFileTest006
554 * @tc.desc: trans file channel open use diff param.
555 * @tc.type: FUNC
556 * @tc.require:
557 */
558 HWTEST_F(TransSdkFileTest, TransFileTest006, TestSize.Level1)
559 {
560 IClientSessionCallBack *cb = GetClientSessionCb();
561 int32_t ret = ClientTransUdpMgrInit(cb);
562 EXPECT_EQ(ret, SOFTBUS_OK);
563 ret = TransFileInit();
564 EXPECT_EQ(ret, SOFTBUS_OK);
565 const char* sessionName = "file send";
566 IFileSendListener *sendListener;
567 ChannelInfo *channelInfo = (ChannelInfo *)SoftBusCalloc(sizeof(ChannelInfo));
568 if (channelInfo == nullptr) {
569 return;
570 }
571 UdpChannel *channel = TransAddChannelTest();
572 int32_t filePort = 22;
573 SocketAccessInfo accessInfo = { 0 };
574 ret = ClientTransAddUdpChannel(channel);
575 EXPECT_EQ(ret, SOFTBUS_OK);
576
577 ret = TransSetFileSendListener(sessionName, sendListener);
578 EXPECT_EQ(ret, SOFTBUS_MEM_ERR);
579
580 ret = TransOnFileChannelOpened(sessionName, channelInfo, nullptr, &accessInfo);
581 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
582
583 ret = TransOnFileChannelOpened(sessionName, channelInfo, &filePort, &accessInfo);
584 EXPECT_EQ(ret, SOFTBUS_FILE_ERR);
585
586 (void)strcpy_s(channelInfo->myIp, strlen("127.0.0.5") + 1, "127.0.0.5");
587 (void)strcpy_s(channelInfo->sessionKey, strlen("session key") + 1, "session key");
588
589 ret = TransOnFileChannelOpened(sessionName, channelInfo, &filePort, &accessInfo);
590 EXPECT_EQ(ret, SOFTBUS_FILE_ERR);
591
592 channelInfo->isServer = false;
593 ret = TransOnFileChannelOpened(sessionName, channelInfo, &filePort, &accessInfo);
594 EXPECT_EQ(ret, SOFTBUS_FILE_ERR);
595 ClientTransUdpMgrDeinit();
596 }
597
598 /**
599 * @tc.name: TransFileTest007
600 * @tc.desc: trans file channel use wrong param.
601 * @tc.type: FUNC
602 * @tc.require:
603 */
604 HWTEST_F(TransSdkFileTest, TransFileTest007, TestSize.Level1)
605 {
606 IClientSessionCallBack *cb = GetClientSessionCb();
607 (void)ClientTransUdpMgrInit(cb);
608 (void)TransFileInit();
609 IFileSendListener *sendListener = (IFileSendListener *)SoftBusCalloc(sizeof(IFileSendListener));
610 if (sendListener == nullptr) {
611 return;
612 };
613 int32_t filePort = 22;
614 ChannelInfo *channelInfo = TransAddChannleInfoTest();
615 UdpChannel *channel = TransAddChannelTest();
616 DFileMsg *msgData = {};
617 DFileMsgType msgType = DFILE_ON_BIND;
618 FileSendListener(channel->dfileId, msgType, msgData);
619
620 int32_t ret = ClientTransAddUdpChannel(channel);
621 EXPECT_EQ(ret, SOFTBUS_OK);
622
623 ret = TransSetFileSendListener(g_mySessionName, sendListener);
624 EXPECT_EQ(ret, SOFTBUS_OK);
625
626 ret = TransOnFileChannelOpened(g_mySessionName, channelInfo, &filePort, nullptr);
627 EXPECT_EQ(ret, SOFTBUS_FILE_ERR);
628
629 TransCloseFileChannel(channel->dfileId);
630
631 TransDeleteFileListener(g_mySessionName);
632 TransFileDeinit();
633 ClientTransUdpMgrDeinit();
634 }
635
636 /**
637 * @tc.name: TransFileTest008
638 * @tc.desc: trans file send use diff param.
639 * @tc.type: FUNC
640 * @tc.require:
641 */
642 HWTEST_F(TransSdkFileTest, TransFileTest008, TestSize.Level1)
643 {
644 int32_t sessionId = 0;
645 const char *sFileList = nullptr;
646 const char *dFileList = nullptr;
647 const char *fileList = "/file not null list/";
648 uint32_t fileCnt = 0;
649 int32_t ret = TransSendFile(sessionId, &sFileList, &dFileList, fileCnt);
650 EXPECT_TRUE(ret);
651
652 ret = TransSendFile(sessionId, &fileList, &dFileList, fileCnt);
653 EXPECT_TRUE(ret);
654 }
655
656 /**
657 * @tc.name: TransFileTest009
658 * @tc.desc: trans set reuse addr.
659 * @tc.type: FUNC
660 * @tc.require:
661 */
662 HWTEST_F(TransSdkFileTest, TransFileTest009, TestSize.Level1)
663 {
664 int32_t fd = socket(AF_INET, SOCK_STREAM, 0);
665 int32_t on = 65536;
666 int32_t ret = SetReuseAddr(fd, on);
667 EXPECT_EQ(ret, SOFTBUS_OK);
668
669 ret = SetReuseAddr(-1, -1);
670 EXPECT_EQ(ret, SOFTBUS_INVALID_FD);
671
672 ret = SetReuseAddr(0, on);
673 EXPECT_EQ(ret, SOFTBUS_INVALID_FD);
674 ret = close(fd);
675 EXPECT_EQ(ret, SOFTBUS_OK);
676 }
677
678 /**
679 * @tc.name: TransFileTest010
680 * @tc.desc: trans set reuse port.
681 * @tc.type: FUNC
682 * @tc.require:
683 */
684 HWTEST_F(TransSdkFileTest, TransFileTest010, TestSize.Level1)
685 {
686 int32_t fd = socket(AF_INET, SOCK_STREAM, 0);
687 int32_t on = 65536;
688 int32_t ret = SetReusePort(fd, on);
689 EXPECT_EQ(ret, SOFTBUS_OK);
690
691 ret = SetReusePort(0, on);
692 EXPECT_EQ(ret, SOFTBUS_INVALID_FD);
693 ret = close(fd);
694 EXPECT_EQ(ret, SOFTBUS_OK);
695 }
696
697 /**
698 * @tc.name: TransFileTest011
699 * @tc.desc: trans open tcp server.
700 * @tc.type: FUNC
701 * @tc.require:
702 */
703 HWTEST_F(TransSdkFileTest, TransFileTest011, TestSize.Level1)
704 {
705 int32_t port = 5683;
706 int32_t ret = CreateServerSocketByIpv4("127.0.0.1", port);
707 EXPECT_TRUE(ret);
708
709 ret = CreateServerSocketByIpv4("280567565", port);
710 EXPECT_EQ(ret, SOFTBUS_SOCKET_ADDR_ERR);
711
712 ret = CreateServerSocketByIpv4("127.0.0.1", 0);
713 EXPECT_TRUE(ret);
714 }
715
716 /**
717 * @tc.name: TransFileTest012
718 * @tc.desc: trans start nstackx file at server.
719 * @tc.type: FUNC
720 * @tc.require:
721 */
722 HWTEST_F(TransSdkFileTest, TransFileTest012, TestSize.Level1)
723 {
724 uint8_t key = 215;
725 uint32_t keyLen = 8;
726 int32_t filePort = 25;
727 int32_t ret = StartNStackXDFileServer(nullptr, &key, keyLen, g_fileMsgRecviver, &filePort);
728 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
729
730 ret = StartNStackXDFileServer("127.0.0.1", &key, keyLen, g_fileMsgRecviver, nullptr);
731 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
732
733 ret = ConnInitSockets();
734 EXPECT_EQ(ret, SOFTBUS_OK);
735 (void)StartNStackXDFileServer("127.0.0.1", &key, keyLen, g_fileMsgRecviver, &filePort);
736 ConnDeinitSockets();
737 }
738
739 /**
740 * @tc.name: TransFileTest013
741 * @tc.desc: trans start nstackx file at client.
742 * @tc.type: FUNC
743 * @tc.require:
744 */
745 HWTEST_F(TransSdkFileTest, TransFileTest013, TestSize.Level1)
746 {
747 uint8_t key = 215;
748 uint32_t keyLen = 8;
749 int32_t peerPort = 25;
750 int32_t ret = StartNStackXDFileClient(nullptr, peerPort, &key, keyLen, g_fileMsgRecviver);
751 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
752 (void)StartNStackXDFileClient("127.0.0.1", peerPort, &key, keyLen, g_fileMsgRecviver);
753 }
754
755 /**
756 * @tc.name: TransFileTest014
757 * @tc.desc: trans register file callback of socket
758 * @tc.type: FUNC
759 * @tc.require:
760 */
761 HWTEST_F(TransSdkFileTest, TransFileTest014, TestSize.Level1)
762 {
763 int32_t ret = TransSetSocketFileListener(nullptr, nullptr, false);
764 ASSERT_EQ(ret, SOFTBUS_INVALID_PARAM);
765
766 ret = TransSetSocketFileListener(g_mySessionName, nullptr, false);
767 ASSERT_EQ(ret, SOFTBUS_INVALID_PARAM);
768
769 ret = TransSetSocketFileListener(nullptr, SocketFileCallbackFuncTest, false);
770 ASSERT_EQ(ret, SOFTBUS_INVALID_PARAM);
771
772 ret = TransFileInit();
773 EXPECT_EQ(ret, SOFTBUS_OK);
774 ret = TransSetSocketFileListener(g_mySessionName, SocketFileCallbackFuncTest, false);
775 ASSERT_EQ(ret, SOFTBUS_OK);
776 TransFileDeinit();
777 }
778
779 /**
780 * @tc.name: TransFileTest015
781 * @tc.desc: trans add new file callback of socket
782 * @tc.type: FUNC
783 * @tc.require:
784 */
785 HWTEST_F(TransSdkFileTest, TransFileTest015, TestSize.Level1)
786 {
787 int32_t ret = TransFileInit();
788 EXPECT_EQ(ret, SOFTBUS_OK);
789 ret = TransAddNewSocketFileListener(nullptr, nullptr, false);
790 ASSERT_EQ(ret, SOFTBUS_INVALID_PARAM);
791
792 ret = TransAddNewSocketFileListener(g_mySessionName, nullptr, false);
793 ASSERT_EQ(ret, SOFTBUS_INVALID_PARAM);
794
795 ret = TransAddNewSocketFileListener(nullptr, SocketFileCallbackFuncTest, false);
796 ASSERT_EQ(ret, SOFTBUS_INVALID_PARAM);
797
798 ret = TransAddNewSocketFileListener(g_mySessionName, SocketFileCallbackFuncTest, false);
799 ASSERT_EQ(ret, SOFTBUS_OK);
800 TransFileDeinit();
801 }
802
803 /**
804 * @tc.name: TransFileTest016
805 * @tc.desc: trans open tcp server.
806 * @tc.type: FUNC
807 * @tc.require:
808 */
809 HWTEST_F(TransSdkFileTest, TransFileTest016, TestSize.Level1)
810 {
811 int32_t port = 5683;
812 int32_t ret = CreateServerSocketByIpv6("3FFF:FFFF:0000:0000:0000:0000:0000:0000", port);
813 EXPECT_TRUE(ret);
814
815 ret = CreateServerSocketByIpv6("280567565", port);
816 EXPECT_EQ(ret, SOFTBUS_SOCKET_ADDR_ERR);
817
818 ret = CreateServerSocketByIpv6("3FFF:FFFF:0000:0000:0000:0000:0000:0000", 0);
819 EXPECT_TRUE(ret);
820 }
821
822 /**
823 * @tc.name: TransFileTest017
824 * @tc.desc: trans open tcp server.
825 * @tc.type: FUNC
826 * @tc.require:
827 */
828 HWTEST_F(TransSdkFileTest, TransFileTest017, TestSize.Level1)
829 {
830 int32_t port = 5683;
831 int32_t fd = 1;
832 int32_t ret = CreateServerSocket(nullptr, &fd, &port);
833 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
834 ret = CreateServerSocket("3FFF:FFFF:0000:0000:0000:0000:0000:0000", nullptr, &port);
835 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
836 ret = CreateServerSocket("3FFF:FFFF:0000:0000:0000:0000:0000:0000", &fd, nullptr);
837 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
838 ret = CreateServerSocket("3FFF:FFFF:0000:0000:0000:0000:0000:0000", &fd, &port);
839 EXPECT_EQ(ret, SOFTBUS_FILE_ERR);
840
841 ret = CreateServerSocket("280567565", &fd, &port);
842 EXPECT_EQ(ret, SOFTBUS_FILE_ERR);
843
844 ret = CreateServerSocket("127.0.0.1", &fd, &port);
845 EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
846 }
847
848 /**
849 * @tc.name: TransFileTest018
850 * @tc.desc: trans open tcp server.
851 * @tc.type: FUNC
852 * @tc.require:
853 */
854 HWTEST_F(TransSdkFileTest, TransFileTest018, TestSize.Level1)
855 {
856 struct sockaddr_in localAddr = { 0 };
857 int32_t port = 5683;
858 int32_t ret = InitSockAddrInByIpPort(nullptr, port, &localAddr);
859 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
860 ret = InitSockAddrInByIpPort("127.0.0.1", -1, &localAddr);
861 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
862 ret = InitSockAddrInByIpPort("127.0.0.1", port, nullptr);
863 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
864 ret = InitSockAddrInByIpPort("280567565", port, &localAddr);
865 EXPECT_EQ(ret, SOFTBUS_OK);
866 ret = InitSockAddrInByIpPort("127.0.0.1", port, &localAddr);
867 EXPECT_EQ(ret, SOFTBUS_OK);
868 }
869
870 /**
871 * @tc.name: TransFileTest019
872 * @tc.desc: trans open tcp server.
873 * @tc.type: FUNC
874 * @tc.require:
875 */
876 HWTEST_F(TransSdkFileTest, TransFileTest019, TestSize.Level1)
877 {
878 struct sockaddr_in6 localAddr = { 0 };
879 int32_t port = 5683;
880 int32_t ret = InitSockAddrIn6ByIpPort(nullptr, port, &localAddr);
881 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
882 ret = InitSockAddrIn6ByIpPort("3FFF:FFFF:0000:0000:0000:0000:0000:0000", -1, &localAddr);
883 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
884 ret = InitSockAddrIn6ByIpPort("3FFF:FFFF:0000:0000:0000:0000:0000:0000", port, nullptr);
885 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
886 ret = InitSockAddrIn6ByIpPort("280567565", port, &localAddr);
887 EXPECT_EQ(ret, SOFTBUS_SOCKET_ADDR_ERR);
888 ret = InitSockAddrIn6ByIpPort("3FFF:FFFF:0000:0000:0000:0000:0000:0000", port, &localAddr);
889 EXPECT_EQ(ret, SOFTBUS_OK);
890 }
891
892 /**
893 * @tc.name: FreeFileStatusListTest001
894 * @tc.desc: test free file status list
895 * @tc.type: FUNC
896 * @tc.require:
897 */
898 HWTEST_F(TransSdkFileTest, FreeFileStatusListTest001, TestSize.Level1)
899 {
900 FileEvent event;
901 event.statusList.completedList.fileCnt = 1;
902 event.statusList.notCompletedList.fileCnt = 1;
903 event.statusList.notStartedList.fileCnt = 1;
904 event.statusList.completedList.files =
905 (char **)SoftBusCalloc(event.statusList.completedList.fileCnt * sizeof(char *));
906 event.statusList.notCompletedList.files =
907 (char **)SoftBusCalloc(event.statusList.notCompletedList.fileCnt * sizeof(char *));
908 event.statusList.notStartedList.files =
909 (char **)SoftBusCalloc(event.statusList.notStartedList.fileCnt * sizeof(char *));
910
911 FreeFileStatusList(&event);
912
913 ASSERT_EQ(event.statusList.completedList.files, nullptr);
914 ASSERT_EQ(event.statusList.notCompletedList.files, nullptr);
915 ASSERT_EQ(event.statusList.notStartedList.files, nullptr);
916 SoftBusFree(event.statusList.completedList.files);
917 SoftBusFree(event.statusList.notCompletedList.files);
918 SoftBusFree(event.statusList.notStartedList.files);
919
920 FileEvent *event2 = nullptr;
921 FreeFileStatusList(event2);
922 }
923
924 /**
925 * @tc.name: FreeFileStatusListTest002
926 * @tc.desc: test free file status list with null files
927 * @tc.type: FUNC
928 * @tc.require:
929 */
930 HWTEST_F(TransSdkFileTest, FreeFileStatusListTest002, TestSize.Level1)
931 {
932 FileEvent event;
933 event.statusList.completedList.files = nullptr;
934 event.statusList.notCompletedList.files = nullptr;
935 event.statusList.notStartedList.files = nullptr;
936
937 FreeFileStatusList(&event);
938 ASSERT_EQ(event.statusList.completedList.files, nullptr);
939 ASSERT_EQ(event.statusList.notCompletedList.files, nullptr);
940 ASSERT_EQ(event.statusList.notStartedList.files, nullptr);
941 }
942
943 /**
944 * @tc.name: FillFileStatusListTest001
945 * @tc.desc: test fill file status list
946 * @tc.type: FUNC
947 * @tc.require:
948 */
949 HWTEST_F(TransSdkFileTest, FillFileStatusListTest001, TestSize.Level1)
950 {
951 DFileMsg msgData;
952 FileEvent event;
953 msgData.clearPolicyFileList.fileNum = 3;
954 DFileFileInfo *fileInfo =
955 static_cast<DFileFileInfo *>(SoftBusCalloc(msgData.clearPolicyFileList.fileNum * sizeof(DFileFileInfo)));
956 fileInfo[0].stat = FILE_STAT_COMPLETE;
957 fileInfo[0].file = (char *)"file1";
958 fileInfo[1].stat = FILE_STAT_NOT_COMPLETE;
959 fileInfo[1].file = (char *)"file2";
960 fileInfo[2].stat = FILE_STAT_NOT_START;
961 fileInfo[2].file = (char *)"file3";
962 msgData.clearPolicyFileList.fileInfo = fileInfo;
963
964 FillFileStatusList(&msgData, &event);
965
966 // Check status list content
967 ASSERT_EQ(1, event.statusList.completedList.fileCnt);
968 ASSERT_STREQ("file1", event.statusList.completedList.files[0]);
969 ASSERT_EQ(1, event.statusList.notCompletedList.fileCnt);
970 ASSERT_STREQ("file2", event.statusList.notCompletedList.files[0]);
971 ASSERT_EQ(1, event.statusList.notStartedList.fileCnt);
972 ASSERT_STREQ("file3", event.statusList.notStartedList.files[0]);
973 SoftBusFree(fileInfo);
974 }
975
976 /**
977 * @tc.name: FillFileStatusListTest002
978 * @tc.desc: test fill file status list
979 * @tc.type: FUNC
980 * @tc.require:
981 */
982 HWTEST_F(TransSdkFileTest, FillFileStatusListTest002, TestSize.Level1)
983 {
984 DFileMsg msgData;
985 FileEvent event;
986 msgData.clearPolicyFileList.fileNum = 0;
987
988 FillFileStatusList(&msgData, &event);
989
990 // Check status list content
991 ASSERT_EQ(nullptr, event.statusList.completedList.files);
992 ASSERT_EQ(0, event.statusList.completedList.fileCnt);
993 ASSERT_EQ(nullptr, event.statusList.notCompletedList.files);
994 ASSERT_EQ(0, event.statusList.notCompletedList.fileCnt);
995 ASSERT_EQ(nullptr, event.statusList.notStartedList.files);
996 ASSERT_EQ(0, event.statusList.notStartedList.fileCnt);
997 }
998
999 /**
1000 * @tc.name: FillFileStatusListTest003
1001 * @tc.desc: test fill file status list
1002 * @tc.type: FUNC
1003 * @tc.require:
1004 */
1005 HWTEST_F(TransSdkFileTest, FillFileStatusListTest003, TestSize.Level1)
1006 {
1007 DFileMsg msgData;
1008 FileEvent event;
1009 msgData.clearPolicyFileList.fileNum = 3;
1010 DFileFileInfo *fileInfo =
1011 static_cast<DFileFileInfo *>(SoftBusCalloc(msgData.clearPolicyFileList.fileNum * sizeof(DFileFileInfo)));
1012 EXPECT_NE(nullptr, fileInfo);
1013 fileInfo[0].stat = FILE_STAT_COMPLETE;
1014 fileInfo[0].file = (char *)"file1";
1015 fileInfo[1].stat = FILE_STAT_COMPLETE;
1016 fileInfo[1].file = (char *)"file2";
1017 fileInfo[2].stat = FILE_STAT_COMPLETE;
1018 fileInfo[2].file = (char *)"file3";
1019 msgData.clearPolicyFileList.fileInfo = fileInfo;
1020
1021 FillFileStatusList(&msgData, &event);
1022
1023 // Check status list content
1024 ASSERT_EQ(3, event.statusList.completedList.fileCnt);
1025 ASSERT_STREQ("file1", event.statusList.completedList.files[0]);
1026 ASSERT_STREQ("file2", event.statusList.completedList.files[1]);
1027 ASSERT_STREQ("file3", event.statusList.completedList.files[2]);
1028 ASSERT_EQ(0, event.statusList.notCompletedList.fileCnt);
1029 ASSERT_EQ(0, event.statusList.notStartedList.fileCnt);
1030 SoftBusFree(fileInfo);
1031 }
1032
MockSocketSendCallback(int32_t socket,FileEvent * event)1033 void MockSocketSendCallback(int32_t socket, FileEvent *event)
1034 {
1035 (void)socket;
1036 (void)event;
1037 }
1038
MockSocketRecvCallback(int32_t socket,FileEvent * event)1039 void MockSocketRecvCallback(int32_t socket, FileEvent *event)
1040 {
1041 (void)socket;
1042 (void)event;
1043 }
1044
InitDFileMsg(DFileMsg * msgData)1045 void InitDFileMsg(DFileMsg *msgData)
1046 {
1047 msgData->fileList.files = nullptr;
1048 msgData->fileList.fileNum = 0;
1049 msgData->clearPolicyFileList.fileNum = 0;
1050 msgData->clearPolicyFileList.fileInfo = nullptr;
1051 msgData->errorCode = 0;
1052 msgData->transferUpdate.bytesTransferred = 0;
1053 msgData->transferUpdate.totalBytes = 0;
1054 msgData->transferUpdate.transId = 0;
1055 msgData->rate = 0;
1056 }
1057
1058 /**
1059 * @tc.name: FillFileStatusListTest004
1060 * @tc.desc: test fill file status list
1061 * @tc.type: FUNC
1062 * @tc.require:
1063 */
1064 HWTEST_F(TransSdkFileTest, FillFileStatusListTest004, TestSize.Level1)
1065 {
1066 DFileMsg msgData;
1067 msgData.clearPolicyFileList.fileNum = 3; // test value
1068 DFileFileInfo *fileInfo =
1069 static_cast<DFileFileInfo *>(SoftBusCalloc(msgData.clearPolicyFileList.fileNum * sizeof(DFileFileInfo)));
1070 EXPECT_NE(nullptr, fileInfo);
1071 fileInfo[0].stat = FILE_STAT_COMPLETE;
1072 fileInfo[0].file = (char *)"file1";
1073 fileInfo[1].stat = FILE_STAT_COMPLETE;
1074 fileInfo[1].file = (char *)"file2";
1075 fileInfo[2].stat = FILE_STAT_COMPLETE;
1076 fileInfo[2].file = (char *)"file3";
1077 msgData.clearPolicyFileList.fileInfo = fileInfo;
1078 int32_t sessionId = TEST_SESSIONID;
1079 DFileMsgType msgType = DFILE_ON_FILE_SEND_SUCCESS;
1080 FileListener* listener = (FileListener *)SoftBusCalloc(sizeof(FileListener));
1081 EXPECT_NE(nullptr, listener);
1082 UdpChannel *channel = TransAddChannelTest();
1083 FileSendErrorEvent(channel, listener, &msgData, msgType, sessionId);
1084 listener->socketSendCallback = MockSocketSendCallback;
1085 listener->socketRecvCallback = MockSocketRecvCallback;
1086 listener->socketSendCallback = nullptr;
1087 FileSendErrorEvent(channel, listener, &msgData, msgType, sessionId);
1088
1089 NotifySendResult(sessionId, msgType, nullptr, nullptr);
1090
1091 msgType = DFILE_ON_FILE_SEND_SUCCESS;
1092 NotifySendResult(sessionId, msgType, &msgData, listener);
1093
1094 msgType = DFILE_ON_FILE_SEND_FAIL;
1095 NotifySendResult(sessionId, msgType, &msgData, listener);
1096
1097 msgType = DFILE_ON_TRANS_IN_PROGRESS;
1098 NotifySendResult(sessionId, msgType, &msgData, listener);
1099
1100 msgType = DFILE_ON_BIND;
1101 NotifySendResult(sessionId, msgType, &msgData, listener);
1102 SoftBusFree(listener);
1103 SoftBusFree(fileInfo);
1104 }
1105
1106 /**
1107 * @tc.name: FillFileStatusListTest005
1108 * @tc.desc: test fill file status list
1109 * @tc.type: FUNC
1110 * @tc.require:
1111 */
1112 HWTEST_F(TransSdkFileTest, FillFileStatusListTest005, TestSize.Level1)
1113 {
1114 DFileMsg msgData;
1115 msgData.clearPolicyFileList.fileNum = 3; // test value
1116 DFileFileInfo *fileInfo =
1117 static_cast<DFileFileInfo *>(SoftBusCalloc(msgData.clearPolicyFileList.fileNum * sizeof(DFileFileInfo)));
1118 EXPECT_NE(nullptr, fileInfo);
1119 fileInfo[0].stat = FILE_STAT_COMPLETE;
1120 fileInfo[0].file = (char *)"file1";
1121 fileInfo[1].stat = FILE_STAT_COMPLETE;
1122 fileInfo[1].file = (char *)"file2";
1123 fileInfo[2].stat = FILE_STAT_COMPLETE;
1124 fileInfo[2].file = (char *)"file3";
1125 msgData.clearPolicyFileList.fileInfo = fileInfo;
1126 int32_t sessionId = TEST_SESSIONID;
1127 DFileMsgType msgType = DFILE_ON_FILE_SEND_SUCCESS;
1128 FileListener* listener = (FileListener *)SoftBusCalloc(sizeof(FileListener));
1129 EXPECT_NE(nullptr, listener);
1130 UdpChannel *channel = TransAddChannelTest();
1131 FileSendErrorEvent(channel, listener, &msgData, msgType, sessionId);
1132 listener->socketSendCallback = MockSocketSendCallback;
1133 listener->socketRecvCallback = MockSocketRecvCallback;
1134
1135 NotifyRecvResult(sessionId, msgType, nullptr, nullptr);
1136
1137 msgType = DFILE_ON_FILE_LIST_RECEIVED;
1138 NotifyRecvResult(sessionId, msgType, &msgData, listener);
1139 msgType = DFILE_ON_FILE_RECEIVE_SUCCESS;
1140 NotifyRecvResult(sessionId, msgType, &msgData, listener);
1141 msgType = DFILE_ON_FILE_RECEIVE_FAIL;
1142 NotifySendResult(sessionId, msgType, &msgData, listener);
1143 msgType = DFILE_ON_TRANS_IN_PROGRESS;
1144 NotifySendResult(sessionId, msgType, &msgData, listener);
1145 msgType = DFILE_ON_BIND;
1146 NotifySendResult(sessionId, msgType, &msgData, listener);
1147
1148 FileRecvErrorEvent(channel, listener, &msgData, msgType, sessionId);
1149 listener->socketSendCallback = nullptr;
1150 FileRecvErrorEvent(channel, listener, &msgData, msgType, sessionId);
1151 msgData.fileList.fileNum = -1;
1152 NotifyRecvResult(sessionId, msgType, &msgData, listener);
1153 SoftBusFree(listener);
1154 SoftBusFree(fileInfo);
1155 }
1156
1157 /**
1158 * @tc.name: FillFileStatusListTest006
1159 * @tc.desc: test fill file status list
1160 * @tc.type: FUNC
1161 * @tc.require:
1162 */
1163 HWTEST_F(TransSdkFileTest, FillFileStatusListTest006, TestSize.Level1)
1164 {
1165 int32_t channelId = TEST_CHANNELID;
1166 uint8_t tos = 1;
1167 RenameHook(nullptr);
1168 int32_t ret = NotifyTransLimitChanged(channelId, tos);
1169 EXPECT_NE(SOFTBUS_OK, ret);
1170 }
1171
1172 /**
1173 * @tc.name: NotifySocketSendResultTest001
1174 * @tc.desc: test notify socket send result
1175 * @tc.type: FUNC
1176 * @tc.require:
1177 */
1178 HWTEST_F(TransSdkFileTest, NotifySocketSendResultTest001, TestSize.Level1)
1179 {
1180 int32_t socket = 1;
1181 DFileMsg msgData;
1182 InitDFileMsg(&msgData);
1183 FileListener listener;
1184 listener.socketSendCallback = MockSocketSendCallback;
1185 listener.socketRecvCallback = MockSocketRecvCallback;
1186
1187 NotifySocketSendResult(socket, DFILE_ON_TRANS_IN_PROGRESS, &msgData, &listener);
1188 NotifySocketSendResult(socket, DFILE_ON_FILE_SEND_SUCCESS, &msgData, &listener);
1189 NotifySocketSendResult(socket, DFILE_ON_FILE_SEND_FAIL, &msgData, &listener);
1190 NotifySocketSendResult(socket, DFILE_ON_CLEAR_POLICY_FILE_LIST, &msgData, &listener);
1191 NotifySocketSendResult(socket, DFILE_ON_CONNECT_FAIL, &msgData, &listener);
1192
1193 NotifySocketRecvResult(socket, DFILE_ON_FILE_LIST_RECEIVED, &msgData, &listener);
1194 NotifySocketRecvResult(socket, DFILE_ON_TRANS_IN_PROGRESS, &msgData, &listener);
1195 NotifySocketRecvResult(socket, DFILE_ON_FILE_RECEIVE_SUCCESS, &msgData, &listener);
1196 NotifySocketRecvResult(socket, DFILE_ON_FILE_RECEIVE_FAIL, &msgData, &listener);
1197 NotifySocketRecvResult(socket, DFILE_ON_CLEAR_POLICY_FILE_LIST, &msgData, &listener);
1198 NotifySocketRecvResult(socket, DFILE_ON_CONNECT_FAIL, &msgData, &listener);
1199 }
1200
1201 /**
1202 * @tc.name: FillFileEventErrorCodeTest
1203 * @tc.desc: test fill file event error code
1204 * @tc.type: FUNC
1205 * @tc.require:
1206 */
1207 HWTEST_F(TransSdkFileTest, FillFileEventErrorCodeTest, TestSize.Level1)
1208 {
1209 DFileMsg msgData;
1210 FileEvent event;
1211
1212 msgData.errorCode = NSTACKX_EOK;
1213 FillFileEventErrorCode(&msgData, &event);
1214 ASSERT_EQ(SOFTBUS_OK, event.errorCode);
1215
1216 msgData.errorCode = NSTACKX_EPERM;
1217 FillFileEventErrorCode(&msgData, &event);
1218 ASSERT_EQ(SOFTBUS_TRANS_FILE_PERMISSION_DENIED, event.errorCode);
1219
1220 msgData.errorCode = NSTACKX_EDQUOT;
1221 FillFileEventErrorCode(&msgData, &event);
1222 ASSERT_EQ(SOFTBUS_TRANS_FILE_DISK_QUOTA_EXCEEDED, event.errorCode);
1223
1224 msgData.errorCode = NSTACKX_ENOMEM;
1225 FillFileEventErrorCode(&msgData, &event);
1226 ASSERT_EQ(SOFTBUS_TRANS_FILE_NO_MEMORY, event.errorCode);
1227
1228 msgData.errorCode = NSTACKX_ENETDOWN;
1229 FillFileEventErrorCode(&msgData, &event);
1230 ASSERT_EQ(SOFTBUS_TRANS_FILE_NETWORK_ERROR, event.errorCode);
1231
1232 msgData.errorCode = NSTACKX_ENOENT;
1233 FillFileEventErrorCode(&msgData, &event);
1234 ASSERT_EQ(SOFTBUS_TRANS_FILE_NOT_FOUND, event.errorCode);
1235
1236 msgData.errorCode = NSTACKX_EEXIST;
1237 FillFileEventErrorCode(&msgData, &event);
1238 ASSERT_EQ(SOFTBUS_TRANS_FILE_EXISTED, event.errorCode);
1239
1240 msgData.errorCode = NSTACKX_NOTSUPPORT;
1241 FillFileEventErrorCode(&msgData, &event);
1242 ASSERT_EQ(NSTACKX_NOTSUPPORT, event.errorCode);
1243 }
1244 }