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 #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(inValidName, fileListener);
327 EXPECT_EQ(ret, SOFTBUS_TRANS_NODE_NOT_FOUND);
328
329 ret = TransGetFileListener(sessionName, fileListener);
330 EXPECT_EQ(ret, SOFTBUS_OK);
331 TransDeleteFileListener(sessionName);
332 TransFileDeinit();
333
334 ret = TransGetFileListener(sessionName, fileListener);
335 EXPECT_EQ(ret, SOFTBUS_TRANS_FILE_LISTENER_NOT_INIT);
336 SoftBusFree(fileListener);
337 }
338
339 /**
340 * @tc.name: TransFileTest001
341 * @tc.desc: trans register file callback.
342 * @tc.type: FUNC
343 * @tc.require:
344 */
345 HWTEST_F(TransSdkFileTest, TransFileTest001, TestSize.Level0)
346 {
347 IClientSessionCallBack *cb = GetClientSessionCb();
348 int32_t ret = ClientTransUdpMgrInit(cb);
349 EXPECT_EQ(ret, SOFTBUS_OK);
350
351 UdpChannelMgrCb *fileCb = nullptr;
352 RegisterFileCb(nullptr);
353 RegisterFileCb(fileCb);
354
355 ClientTransUdpMgrDeinit();
356 }
357
358 /**
359 * @tc.name: TransFileTest002
360 * @tc.desc: trans open file channel.
361 * @tc.type: FUNC
362 * @tc.require:
363 */
364 HWTEST_F(TransSdkFileTest, TransFileTest002, TestSize.Level0)
365 {
366 IClientSessionCallBack *cb = GetClientSessionCb();
367 int32_t ret = ClientTransUdpMgrInit(cb);
368 EXPECT_EQ(ret, SOFTBUS_OK);
369 ret = TransFileInit();
370 EXPECT_EQ(ret, SOFTBUS_OK);
371 const char* sessionName = "file send";
372 ChannelInfo *channelInfo = (ChannelInfo *)SoftBusCalloc(sizeof(ChannelInfo));
373 if (channelInfo == nullptr) {
374 return;
375 }
376 UdpChannel *channel = TransAddChannelTest();
377 int32_t filePort = 22;
378
379 ret = ClientTransAddUdpChannel(channel);
380 EXPECT_EQ(ret, SOFTBUS_OK);
381
382 ret = TransSetFileSendListener(sessionName, &g_fileSendListener);
383 EXPECT_EQ(ret, SOFTBUS_OK);
384
385 ret = TransOnFileChannelOpened(sessionName, channelInfo, nullptr);
386 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
387
388 ret = TransOnFileChannelOpened(sessionName, channelInfo, &filePort);
389 EXPECT_EQ(ret, SOFTBUS_FILE_ERR);
390
391 (void)strcpy_s(channelInfo->myIp, strlen("127.0.0.5") + 1, "127.0.0.5");
392 (void)strcpy_s(channelInfo->sessionKey, strlen("session key") + 1, "session key");
393
394 ret = TransOnFileChannelOpened(sessionName, channelInfo, &filePort);
395 EXPECT_EQ(ret, SOFTBUS_FILE_ERR);
396
397 channelInfo->isServer = false;
398 ret = TransOnFileChannelOpened(sessionName, channelInfo, &filePort);
399 EXPECT_EQ(ret, SOFTBUS_FILE_ERR);
400 ClientTransUdpMgrDeinit();
401 }
402
403 /**
404 * @tc.name: TransFileTest003
405 * @tc.desc: trans open file channel use diff param.
406 * @tc.type: FUNC
407 * @tc.require:
408 */
409 HWTEST_F(TransSdkFileTest, TransFileTest003, TestSize.Level0)
410 {
411 IClientSessionCallBack *cb = GetClientSessionCb();
412 (void)ClientTransUdpMgrInit(cb);
413 (void)TransFileInit();
414 IFileSendListener *sendListener = (IFileSendListener *)SoftBusCalloc(sizeof(IFileSendListener));
415 if (sendListener == nullptr) {
416 return;
417 }
418 int32_t filePort = 22;
419 ChannelInfo *channelInfo = TransAddChannleInfoTest();
420 UdpChannel *channel = TransAddChannelTest();
421 DFileMsg *msgData = {};
422 DFileMsgType msgType = DFILE_ON_BIND;
423 FileSendListener(channel->dfileId, msgType, msgData);
424 int32_t ret = ClientTransAddUdpChannel(channel);
425 EXPECT_EQ(ret, SOFTBUS_OK);
426
427 ret = TransSetFileSendListener(g_mySessionName, sendListener);
428 EXPECT_EQ(ret, SOFTBUS_OK);
429
430 ret = TransOnFileChannelOpened(g_mySessionName, channelInfo, &filePort);
431 EXPECT_EQ(ret, SOFTBUS_FILE_ERR);
432
433 TransDeleteFileListener(g_mySessionName);
434 TransFileDeinit();
435 ClientTransUdpMgrDeinit();
436 }
437
438 /**
439 * @tc.name: TransFileTest004
440 * @tc.desc: trans file send listener use diff param.
441 * @tc.type: FUNC
442 * @tc.require:
443 */
444 HWTEST_F(TransSdkFileTest, TransFileTest004, TestSize.Level0)
445 {
446 int32_t ret = TransFileInit();
447 EXPECT_EQ(ret, SOFTBUS_OK);
448 DFileMsgType msgType = DFILE_ON_CONNECT_SUCCESS;
449 DFileMsg msgData = {};
450 UdpChannel *channel = (UdpChannel*)SoftBusCalloc(sizeof(UdpChannel));
451 ASSERT_TRUE(channel != nullptr);
452 GenerateAndAddUdpChannel(channel);
453 FileSendListener(channel->dfileId, msgType, &msgData);
454
455 msgData.rate = 1;
456 FileSendListener(channel->dfileId, msgType, &msgData);
457
458 msgType = DFILE_ON_BIND;
459 FileSendListener(channel->dfileId, msgType, &msgData);
460
461 msgType = DFILE_ON_SESSION_IN_PROGRESS;
462 FileSendListener(channel->dfileId, msgType, &msgData);
463
464 msgType = DFILE_ON_SESSION_TRANSFER_RATE;
465 FileSendListener(channel->dfileId, msgType, &msgData);
466
467 ret = TransSetFileSendListener(channel->info.mySessionName, &g_fileSendListener);
468 EXPECT_EQ(ret, SOFTBUS_OK);
469
470 FileSendListener(channel->dfileId, msgType, &msgData);
471
472 msgType = DFILE_ON_FILE_SEND_SUCCESS;
473 FileSendListener(channel->dfileId, msgType, &msgData);
474
475 msgType = DFILE_ON_FILE_SEND_FAIL;
476 FileSendListener(channel->dfileId, msgType, &msgData);
477
478 msgType = DFILE_ON_TRANS_IN_PROGRESS;
479 FileSendListener(channel->dfileId, msgType, &msgData);
480
481 msgType = DFILE_ON_SESSION_TRANSFER_RATE;
482 FileSendListener(channel->dfileId, msgType, &msgData);
483
484 msgType = DFILE_ON_CONNECT_FAIL;
485 FileSendListener(channel->dfileId, msgType, &msgData);
486
487 msgType = DFILE_ON_FATAL_ERROR;
488 FileSendListener(channel->dfileId, msgType, &msgData);
489
490 TransDeleteFileListener(channel->info.mySessionName);
491 TransFileDeinit();
492 ClientTransUdpMgrDeinit();
493 }
494
495 /**
496 * @tc.name: TransFileTest005
497 * @tc.desc: trans file recv listener use diff param.
498 * @tc.type: FUNC
499 * @tc.require:
500 */
501 HWTEST_F(TransSdkFileTest, TransFileTest005, TestSize.Level0)
502 {
503 int32_t ret = TransFileInit();
504 EXPECT_EQ(ret, SOFTBUS_OK);
505 DFileMsgType msgType = DFILE_ON_CONNECT_SUCCESS;
506 DFileMsg msgData = {};
507 UdpChannel *channel = (UdpChannel*)SoftBusCalloc(sizeof(UdpChannel));
508 ASSERT_TRUE(channel != nullptr);
509 GenerateAndAddUdpChannel(channel);
510 FileReceiveListener(channel->dfileId, msgType, &msgData);
511
512 msgData.rate = 1;
513 FileReceiveListener(channel->dfileId, msgType, &msgData);
514
515 string rootDir = "rootDir";
516 ret = TransSetFileReceiveListener(channel->info.mySessionName, &g_fileRecvListener, rootDir.c_str());
517 EXPECT_EQ(ret, SOFTBUS_OK);
518
519 msgType = DFILE_ON_FILE_LIST_RECEIVED;
520 FileReceiveListener(channel->dfileId, msgType, &msgData);
521
522 msgType = DFILE_ON_FILE_RECEIVE_SUCCESS;
523 FileReceiveListener(channel->dfileId, msgType, &msgData);
524
525 msgType = DFILE_ON_TRANS_IN_PROGRESS;
526 FileReceiveListener(channel->dfileId, msgType, &msgData);
527
528 msgType = DFILE_ON_FILE_RECEIVE_FAIL;
529 FileReceiveListener(channel->dfileId, msgType, &msgData);
530
531 msgType = DFILE_ON_CONNECT_SUCCESS;
532 FileReceiveListener(channel->dfileId, msgType, &msgData);
533
534 msgType = DFILE_ON_CONNECT_FAIL;
535 FileReceiveListener(channel->dfileId, msgType, &msgData);
536
537 msgType = DFILE_ON_FATAL_ERROR;
538 FileReceiveListener(channel->dfileId, msgType, &msgData);
539
540 TransDeleteFileListener(channel->info.mySessionName);
541 TransFileDeinit();
542 ClientTransUdpMgrDeinit();
543 }
544
545 /**
546 * @tc.name: TransFileTest006
547 * @tc.desc: trans file channel open use diff param.
548 * @tc.type: FUNC
549 * @tc.require:
550 */
551 HWTEST_F(TransSdkFileTest, TransFileTest006, TestSize.Level0)
552 {
553 IClientSessionCallBack *cb = GetClientSessionCb();
554 int32_t ret = ClientTransUdpMgrInit(cb);
555 EXPECT_EQ(ret, SOFTBUS_OK);
556 ret = TransFileInit();
557 EXPECT_EQ(ret, SOFTBUS_OK);
558 const char* sessionName = "file send";
559 IFileSendListener *sendListener;
560 ChannelInfo *channelInfo = (ChannelInfo *)SoftBusCalloc(sizeof(ChannelInfo));
561 if (channelInfo == nullptr) {
562 return;
563 }
564 UdpChannel *channel = TransAddChannelTest();
565 int32_t filePort = 22;
566
567 ret = ClientTransAddUdpChannel(channel);
568 EXPECT_EQ(ret, SOFTBUS_OK);
569
570 ret = TransSetFileSendListener(sessionName, sendListener);
571 EXPECT_EQ(ret, SOFTBUS_MEM_ERR);
572
573 ret = TransOnFileChannelOpened(sessionName, channelInfo, nullptr);
574 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
575
576 ret = TransOnFileChannelOpened(sessionName, channelInfo, &filePort);
577 EXPECT_EQ(ret, SOFTBUS_FILE_ERR);
578
579 (void)strcpy_s(channelInfo->myIp, strlen("127.0.0.5") + 1, "127.0.0.5");
580 (void)strcpy_s(channelInfo->sessionKey, strlen("session key") + 1, "session key");
581
582 ret = TransOnFileChannelOpened(sessionName, channelInfo, &filePort);
583 EXPECT_EQ(ret, SOFTBUS_FILE_ERR);
584
585 channelInfo->isServer = false;
586 ret = TransOnFileChannelOpened(sessionName, channelInfo, &filePort);
587 EXPECT_EQ(ret, SOFTBUS_FILE_ERR);
588 ClientTransUdpMgrDeinit();
589 }
590
591 /**
592 * @tc.name: TransFileTest007
593 * @tc.desc: trans file channel use wrong param.
594 * @tc.type: FUNC
595 * @tc.require:
596 */
597 HWTEST_F(TransSdkFileTest, TransFileTest007, TestSize.Level0)
598 {
599 IClientSessionCallBack *cb = GetClientSessionCb();
600 (void)ClientTransUdpMgrInit(cb);
601 (void)TransFileInit();
602 IFileSendListener *sendListener = (IFileSendListener *)SoftBusCalloc(sizeof(IFileSendListener));
603 if (sendListener == nullptr) {
604 return;
605 };
606 int32_t filePort = 22;
607 ChannelInfo *channelInfo = TransAddChannleInfoTest();
608 UdpChannel *channel = TransAddChannelTest();
609 DFileMsg *msgData = {};
610 DFileMsgType msgType = DFILE_ON_BIND;
611 FileSendListener(channel->dfileId, msgType, msgData);
612
613 int32_t ret = ClientTransAddUdpChannel(channel);
614 EXPECT_EQ(ret, SOFTBUS_OK);
615
616 ret = TransSetFileSendListener(g_mySessionName, sendListener);
617 EXPECT_EQ(ret, SOFTBUS_OK);
618
619 ret = TransOnFileChannelOpened(g_mySessionName, channelInfo, &filePort);
620 EXPECT_EQ(ret, SOFTBUS_FILE_ERR);
621
622 TransCloseFileChannel(channel->dfileId);
623
624 TransDeleteFileListener(g_mySessionName);
625 TransFileDeinit();
626 ClientTransUdpMgrDeinit();
627 }
628
629 /**
630 * @tc.name: TransFileTest008
631 * @tc.desc: trans file send use diff param.
632 * @tc.type: FUNC
633 * @tc.require:
634 */
635 HWTEST_F(TransSdkFileTest, TransFileTest008, TestSize.Level0)
636 {
637 int32_t sessionId = 0;
638 const char *sFileList = nullptr;
639 const char *dFileList = nullptr;
640 const char *fileList = "/file not null list/";
641 uint32_t fileCnt = 0;
642 int32_t ret = TransSendFile(sessionId, &sFileList, &dFileList, fileCnt);
643 EXPECT_TRUE(ret);
644
645 ret = TransSendFile(sessionId, &fileList, &dFileList, fileCnt);
646 EXPECT_TRUE(ret);
647 }
648
649 /**
650 * @tc.name: TransFileTest009
651 * @tc.desc: trans set reuse addr.
652 * @tc.type: FUNC
653 * @tc.require:
654 */
655 HWTEST_F(TransSdkFileTest, TransFileTest009, TestSize.Level0)
656 {
657 int32_t fd = socket(AF_INET, SOCK_STREAM, 0);
658 int32_t on = 65536;
659 int32_t ret = SetReuseAddr(fd, on);
660 EXPECT_EQ(ret, SOFTBUS_OK);
661
662 ret = SetReuseAddr(-1, -1);
663 EXPECT_EQ(ret, SOFTBUS_INVALID_FD);
664
665 ret = SetReuseAddr(0, on);
666 EXPECT_EQ(ret, SOFTBUS_INVALID_FD);
667 ret = close(fd);
668 EXPECT_EQ(ret, SOFTBUS_OK);
669 }
670
671 /**
672 * @tc.name: TransFileTest010
673 * @tc.desc: trans set reuse port.
674 * @tc.type: FUNC
675 * @tc.require:
676 */
677 HWTEST_F(TransSdkFileTest, TransFileTest010, TestSize.Level0)
678 {
679 int32_t fd = socket(AF_INET, SOCK_STREAM, 0);
680 int32_t on = 65536;
681 int32_t ret = SetReusePort(fd, on);
682 EXPECT_EQ(ret, SOFTBUS_OK);
683
684 ret = SetReusePort(0, on);
685 EXPECT_EQ(ret, SOFTBUS_INVALID_FD);
686 ret = close(fd);
687 EXPECT_EQ(ret, SOFTBUS_OK);
688 }
689
690 /**
691 * @tc.name: TransFileTest011
692 * @tc.desc: trans open tcp server.
693 * @tc.type: FUNC
694 * @tc.require:
695 */
696 HWTEST_F(TransSdkFileTest, TransFileTest011, TestSize.Level0)
697 {
698 int32_t port = 5683;
699 int32_t ret = CreateServerSocketByIpv4("127.0.0.1", port);
700 EXPECT_TRUE(ret);
701
702 ret = CreateServerSocketByIpv4("280567565", port);
703 EXPECT_EQ(ret, SOFTBUS_SOCKET_ADDR_ERR);
704
705 ret = CreateServerSocketByIpv4("127.0.0.1", 0);
706 EXPECT_TRUE(ret);
707 }
708
709 /**
710 * @tc.name: TransFileTest012
711 * @tc.desc: trans start nstackx file at server.
712 * @tc.type: FUNC
713 * @tc.require:
714 */
715 HWTEST_F(TransSdkFileTest, TransFileTest012, TestSize.Level0)
716 {
717 uint8_t key = 215;
718 uint32_t keyLen = 8;
719 int32_t filePort = 25;
720 int32_t ret = StartNStackXDFileServer(nullptr, &key, keyLen, g_fileMsgRecviver, &filePort);
721 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
722
723 ret = StartNStackXDFileServer("127.0.0.1", &key, keyLen, g_fileMsgRecviver, nullptr);
724 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
725
726 ret = ConnInitSockets();
727 EXPECT_EQ(ret, SOFTBUS_OK);
728 (void)StartNStackXDFileServer("127.0.0.1", &key, keyLen, g_fileMsgRecviver, &filePort);
729 ConnDeinitSockets();
730 }
731
732 /**
733 * @tc.name: TransFileTest013
734 * @tc.desc: trans start nstackx file at client.
735 * @tc.type: FUNC
736 * @tc.require:
737 */
738 HWTEST_F(TransSdkFileTest, TransFileTest013, TestSize.Level0)
739 {
740 uint8_t key = 215;
741 uint32_t keyLen = 8;
742 int32_t peerPort = 25;
743 int32_t ret = StartNStackXDFileClient(nullptr, peerPort, &key, keyLen, g_fileMsgRecviver);
744 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
745 (void)StartNStackXDFileClient("127.0.0.1", peerPort, &key, keyLen, g_fileMsgRecviver);
746 }
747
748 /**
749 * @tc.name: TransFileTest014
750 * @tc.desc: trans register file callback of socket
751 * @tc.type: FUNC
752 * @tc.require:
753 */
754 HWTEST_F(TransSdkFileTest, TransFileTest014, TestSize.Level0)
755 {
756 int32_t ret = TransSetSocketFileListener(nullptr, nullptr, false);
757 ASSERT_EQ(ret, SOFTBUS_INVALID_PARAM);
758
759 ret = TransSetSocketFileListener(g_mySessionName, nullptr, false);
760 ASSERT_EQ(ret, SOFTBUS_INVALID_PARAM);
761
762 ret = TransSetSocketFileListener(nullptr, SocketFileCallbackFuncTest, false);
763 ASSERT_EQ(ret, SOFTBUS_INVALID_PARAM);
764
765 ret = TransFileInit();
766 EXPECT_EQ(ret, SOFTBUS_OK);
767 ret = TransSetSocketFileListener(g_mySessionName, SocketFileCallbackFuncTest, false);
768 ASSERT_EQ(ret, SOFTBUS_OK);
769 TransFileDeinit();
770 }
771
772 /**
773 * @tc.name: TransFileTest015
774 * @tc.desc: trans add new file callback of socket
775 * @tc.type: FUNC
776 * @tc.require:
777 */
778 HWTEST_F(TransSdkFileTest, TransFileTest015, TestSize.Level0)
779 {
780 int32_t ret = TransFileInit();
781 EXPECT_EQ(ret, SOFTBUS_OK);
782 ret = TransAddNewSocketFileListener(nullptr, nullptr, false);
783 ASSERT_EQ(ret, SOFTBUS_INVALID_PARAM);
784
785 ret = TransAddNewSocketFileListener(g_mySessionName, nullptr, false);
786 ASSERT_EQ(ret, SOFTBUS_INVALID_PARAM);
787
788 ret = TransAddNewSocketFileListener(nullptr, SocketFileCallbackFuncTest, false);
789 ASSERT_EQ(ret, SOFTBUS_INVALID_PARAM);
790
791 ret = TransAddNewSocketFileListener(g_mySessionName, SocketFileCallbackFuncTest, false);
792 ASSERT_EQ(ret, SOFTBUS_OK);
793 TransFileDeinit();
794 }
795
796 /**
797 * @tc.name: TransFileTest016
798 * @tc.desc: trans open tcp server.
799 * @tc.type: FUNC
800 * @tc.require:
801 */
802 HWTEST_F(TransSdkFileTest, TransFileTest016, TestSize.Level0)
803 {
804 int32_t port = 5683;
805 int32_t ret = CreateServerSocketByIpv6("3FFF:FFFF:0000:0000:0000:0000:0000:0000", port);
806 EXPECT_TRUE(ret);
807
808 ret = CreateServerSocketByIpv6("280567565", port);
809 EXPECT_EQ(ret, SOFTBUS_SOCKET_ADDR_ERR);
810
811 ret = CreateServerSocketByIpv6("3FFF:FFFF:0000:0000:0000:0000:0000:0000", 0);
812 EXPECT_TRUE(ret);
813 }
814
815 /**
816 * @tc.name: TransFileTest017
817 * @tc.desc: trans open tcp server.
818 * @tc.type: FUNC
819 * @tc.require:
820 */
821 HWTEST_F(TransSdkFileTest, TransFileTest017, TestSize.Level0)
822 {
823 int32_t port = 5683;
824 int32_t fd = 1;
825 int32_t ret = CreateServerSocket(nullptr, &fd, &port);
826 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
827 ret = CreateServerSocket("3FFF:FFFF:0000:0000:0000:0000:0000:0000", nullptr, &port);
828 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
829 ret = CreateServerSocket("3FFF:FFFF:0000:0000:0000:0000:0000:0000", &fd, nullptr);
830 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
831 ret = CreateServerSocket("3FFF:FFFF:0000:0000:0000:0000:0000:0000", &fd, &port);
832 EXPECT_EQ(ret, SOFTBUS_FILE_ERR);
833
834 ret = CreateServerSocket("280567565", &fd, &port);
835 EXPECT_EQ(ret, SOFTBUS_FILE_ERR);
836
837 ret = CreateServerSocket("127.0.0.1", &fd, &port);
838 EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
839 }
840
841 /**
842 * @tc.name: TransFileTest018
843 * @tc.desc: trans open tcp server.
844 * @tc.type: FUNC
845 * @tc.require:
846 */
847 HWTEST_F(TransSdkFileTest, TransFileTest018, TestSize.Level0)
848 {
849 struct sockaddr_in localAddr = { 0 };
850 int32_t port = 5683;
851 int32_t ret = InitSockAddrInByIpPort(nullptr, port, &localAddr);
852 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
853 ret = InitSockAddrInByIpPort("127.0.0.1", -1, &localAddr);
854 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
855 ret = InitSockAddrInByIpPort("127.0.0.1", port, nullptr);
856 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
857 ret = InitSockAddrInByIpPort("280567565", port, &localAddr);
858 EXPECT_EQ(ret, SOFTBUS_OK);
859 ret = InitSockAddrInByIpPort("127.0.0.1", port, &localAddr);
860 EXPECT_EQ(ret, SOFTBUS_OK);
861 }
862
863 /**
864 * @tc.name: TransFileTest019
865 * @tc.desc: trans open tcp server.
866 * @tc.type: FUNC
867 * @tc.require:
868 */
869 HWTEST_F(TransSdkFileTest, TransFileTest019, TestSize.Level0)
870 {
871 struct sockaddr_in6 localAddr = { 0 };
872 int32_t port = 5683;
873 int32_t ret = InitSockAddrIn6ByIpPort(nullptr, port, &localAddr);
874 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
875 ret = InitSockAddrIn6ByIpPort("3FFF:FFFF:0000:0000:0000:0000:0000:0000", -1, &localAddr);
876 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
877 ret = InitSockAddrIn6ByIpPort("3FFF:FFFF:0000:0000:0000:0000:0000:0000", port, nullptr);
878 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
879 ret = InitSockAddrIn6ByIpPort("280567565", port, &localAddr);
880 EXPECT_EQ(ret, SOFTBUS_SOCKET_ADDR_ERR);
881 ret = InitSockAddrIn6ByIpPort("3FFF:FFFF:0000:0000:0000:0000:0000:0000", port, &localAddr);
882 EXPECT_EQ(ret, SOFTBUS_OK);
883 }
884
885 /**
886 * @tc.name: FreeFileStatusListTest001
887 * @tc.desc: test free file status list
888 * @tc.type: FUNC
889 * @tc.require:
890 */
891 HWTEST_F(TransSdkFileTest, FreeFileStatusListTest001, TestSize.Level0)
892 {
893 FileEvent event;
894 event.statusList.completedList.fileCnt = 1;
895 event.statusList.notCompletedList.fileCnt = 1;
896 event.statusList.notStartedList.fileCnt = 1;
897 event.statusList.completedList.files =
898 (char **)SoftBusCalloc(event.statusList.completedList.fileCnt * sizeof(char *));
899 event.statusList.notCompletedList.files =
900 (char **)SoftBusCalloc(event.statusList.notCompletedList.fileCnt * sizeof(char *));
901 event.statusList.notStartedList.files =
902 (char **)SoftBusCalloc(event.statusList.notStartedList.fileCnt * sizeof(char *));
903
904 FreeFileStatusList(&event);
905
906 ASSERT_EQ(event.statusList.completedList.files, nullptr);
907 ASSERT_EQ(event.statusList.notCompletedList.files, nullptr);
908 ASSERT_EQ(event.statusList.notStartedList.files, nullptr);
909 SoftBusFree(event.statusList.completedList.files);
910 SoftBusFree(event.statusList.notCompletedList.files);
911 SoftBusFree(event.statusList.notStartedList.files);
912
913 FileEvent *event2 = nullptr;
914 FreeFileStatusList(event2);
915 }
916
917 /**
918 * @tc.name: FreeFileStatusListTest002
919 * @tc.desc: test free file status list with null files
920 * @tc.type: FUNC
921 * @tc.require:
922 */
923 HWTEST_F(TransSdkFileTest, FreeFileStatusListTest002, TestSize.Level0)
924 {
925 FileEvent event;
926 event.statusList.completedList.files = nullptr;
927 event.statusList.notCompletedList.files = nullptr;
928 event.statusList.notStartedList.files = nullptr;
929
930 FreeFileStatusList(&event);
931 ASSERT_EQ(event.statusList.completedList.files, nullptr);
932 ASSERT_EQ(event.statusList.notCompletedList.files, nullptr);
933 ASSERT_EQ(event.statusList.notStartedList.files, nullptr);
934 }
935
936 /**
937 * @tc.name: FillFileStatusListTest001
938 * @tc.desc: test fill file status list
939 * @tc.type: FUNC
940 * @tc.require:
941 */
942 HWTEST_F(TransSdkFileTest, FillFileStatusListTest001, TestSize.Level0)
943 {
944 DFileMsg msgData;
945 FileEvent event;
946 msgData.clearPolicyFileList.fileNum = 3;
947 DFileFileInfo *fileInfo =
948 static_cast<DFileFileInfo *>(SoftBusCalloc(msgData.clearPolicyFileList.fileNum * sizeof(DFileFileInfo)));
949 fileInfo[0].stat = FILE_STAT_COMPLETE;
950 fileInfo[0].file = (char *)"file1";
951 fileInfo[1].stat = FILE_STAT_NOT_COMPLETE;
952 fileInfo[1].file = (char *)"file2";
953 fileInfo[2].stat = FILE_STAT_NOT_START;
954 fileInfo[2].file = (char *)"file3";
955 msgData.clearPolicyFileList.fileInfo = fileInfo;
956
957 FillFileStatusList(&msgData, &event);
958
959 // Check status list content
960 ASSERT_EQ(1, event.statusList.completedList.fileCnt);
961 ASSERT_STREQ("file1", event.statusList.completedList.files[0]);
962 ASSERT_EQ(1, event.statusList.notCompletedList.fileCnt);
963 ASSERT_STREQ("file2", event.statusList.notCompletedList.files[0]);
964 ASSERT_EQ(1, event.statusList.notStartedList.fileCnt);
965 ASSERT_STREQ("file3", event.statusList.notStartedList.files[0]);
966 SoftBusFree(fileInfo);
967 }
968
969 /**
970 * @tc.name: FillFileStatusListTest002
971 * @tc.desc: test fill file status list
972 * @tc.type: FUNC
973 * @tc.require:
974 */
975 HWTEST_F(TransSdkFileTest, FillFileStatusListTest002, TestSize.Level0)
976 {
977 DFileMsg msgData;
978 FileEvent event;
979 msgData.clearPolicyFileList.fileNum = 0;
980
981 FillFileStatusList(&msgData, &event);
982
983 // Check status list content
984 ASSERT_EQ(nullptr, event.statusList.completedList.files);
985 ASSERT_EQ(0, event.statusList.completedList.fileCnt);
986 ASSERT_EQ(nullptr, event.statusList.notCompletedList.files);
987 ASSERT_EQ(0, event.statusList.notCompletedList.fileCnt);
988 ASSERT_EQ(nullptr, event.statusList.notStartedList.files);
989 ASSERT_EQ(0, event.statusList.notStartedList.fileCnt);
990 }
991
992 /**
993 * @tc.name: FillFileStatusListTest003
994 * @tc.desc: test fill file status list
995 * @tc.type: FUNC
996 * @tc.require:
997 */
998 HWTEST_F(TransSdkFileTest, FillFileStatusListTest003, TestSize.Level0)
999 {
1000 DFileMsg msgData;
1001 FileEvent event;
1002 msgData.clearPolicyFileList.fileNum = 3;
1003 DFileFileInfo *fileInfo =
1004 static_cast<DFileFileInfo *>(SoftBusCalloc(msgData.clearPolicyFileList.fileNum * sizeof(DFileFileInfo)));
1005 EXPECT_NE(nullptr, fileInfo);
1006 fileInfo[0].stat = FILE_STAT_COMPLETE;
1007 fileInfo[0].file = (char *)"file1";
1008 fileInfo[1].stat = FILE_STAT_COMPLETE;
1009 fileInfo[1].file = (char *)"file2";
1010 fileInfo[2].stat = FILE_STAT_COMPLETE;
1011 fileInfo[2].file = (char *)"file3";
1012 msgData.clearPolicyFileList.fileInfo = fileInfo;
1013
1014 FillFileStatusList(&msgData, &event);
1015
1016 // Check status list content
1017 ASSERT_EQ(3, event.statusList.completedList.fileCnt);
1018 ASSERT_STREQ("file1", event.statusList.completedList.files[0]);
1019 ASSERT_STREQ("file2", event.statusList.completedList.files[1]);
1020 ASSERT_STREQ("file3", event.statusList.completedList.files[2]);
1021 ASSERT_EQ(0, event.statusList.notCompletedList.fileCnt);
1022 ASSERT_EQ(0, event.statusList.notStartedList.fileCnt);
1023 SoftBusFree(fileInfo);
1024 }
1025
MockSocketSendCallback(int32_t socket,FileEvent * event)1026 void MockSocketSendCallback(int32_t socket, FileEvent *event)
1027 {
1028 (void)socket;
1029 (void)event;
1030 }
1031
MockSocketRecvCallback(int32_t socket,FileEvent * event)1032 void MockSocketRecvCallback(int32_t socket, FileEvent *event)
1033 {
1034 (void)socket;
1035 (void)event;
1036 }
1037
InitDFileMsg(DFileMsg * msgData)1038 void InitDFileMsg(DFileMsg *msgData)
1039 {
1040 msgData->fileList.files = nullptr;
1041 msgData->fileList.fileNum = 0;
1042 msgData->clearPolicyFileList.fileNum = 0;
1043 msgData->clearPolicyFileList.fileInfo = nullptr;
1044 msgData->errorCode = 0;
1045 msgData->transferUpdate.bytesTransferred = 0;
1046 msgData->transferUpdate.totalBytes = 0;
1047 msgData->transferUpdate.transId = 0;
1048 msgData->rate = 0;
1049 }
1050
1051 /**
1052 * @tc.name: FillFileStatusListTest004
1053 * @tc.desc: test fill file status list
1054 * @tc.type: FUNC
1055 * @tc.require:
1056 */
1057 HWTEST_F(TransSdkFileTest, FillFileStatusListTest004, TestSize.Level0)
1058 {
1059 DFileMsg msgData;
1060 msgData.clearPolicyFileList.fileNum = 3; // test value
1061 DFileFileInfo *fileInfo =
1062 static_cast<DFileFileInfo *>(SoftBusCalloc(msgData.clearPolicyFileList.fileNum * sizeof(DFileFileInfo)));
1063 EXPECT_NE(nullptr, fileInfo);
1064 fileInfo[0].stat = FILE_STAT_COMPLETE;
1065 fileInfo[0].file = (char *)"file1";
1066 fileInfo[1].stat = FILE_STAT_COMPLETE;
1067 fileInfo[1].file = (char *)"file2";
1068 fileInfo[2].stat = FILE_STAT_COMPLETE;
1069 fileInfo[2].file = (char *)"file3";
1070 msgData.clearPolicyFileList.fileInfo = fileInfo;
1071 int32_t sessionId = TEST_SESSIONID;
1072 DFileMsgType msgType = DFILE_ON_FILE_SEND_SUCCESS;
1073 FileListener* listener = (FileListener *)SoftBusCalloc(sizeof(FileListener));
1074 EXPECT_NE(nullptr, listener);
1075 UdpChannel *channel = TransAddChannelTest();
1076 FileSendErrorEvent(channel, listener, &msgData, msgType, sessionId);
1077 listener->socketSendCallback = MockSocketSendCallback;
1078 listener->socketRecvCallback = MockSocketRecvCallback;
1079 listener->socketSendCallback = nullptr;
1080 FileSendErrorEvent(channel, listener, &msgData, msgType, sessionId);
1081
1082 NotifySendResult(sessionId, msgType, nullptr, nullptr);
1083
1084 msgType = DFILE_ON_FILE_SEND_SUCCESS;
1085 NotifySendResult(sessionId, msgType, &msgData, listener);
1086
1087 msgType = DFILE_ON_FILE_SEND_FAIL;
1088 NotifySendResult(sessionId, msgType, &msgData, listener);
1089
1090 msgType = DFILE_ON_TRANS_IN_PROGRESS;
1091 NotifySendResult(sessionId, msgType, &msgData, listener);
1092
1093 msgType = DFILE_ON_BIND;
1094 NotifySendResult(sessionId, msgType, &msgData, listener);
1095 SoftBusFree(listener);
1096 SoftBusFree(fileInfo);
1097 }
1098
1099 /**
1100 * @tc.name: FillFileStatusListTest005
1101 * @tc.desc: test fill file status list
1102 * @tc.type: FUNC
1103 * @tc.require:
1104 */
1105 HWTEST_F(TransSdkFileTest, FillFileStatusListTest005, TestSize.Level0)
1106 {
1107 DFileMsg msgData;
1108 msgData.clearPolicyFileList.fileNum = 3; // test value
1109 DFileFileInfo *fileInfo =
1110 static_cast<DFileFileInfo *>(SoftBusCalloc(msgData.clearPolicyFileList.fileNum * sizeof(DFileFileInfo)));
1111 EXPECT_NE(nullptr, fileInfo);
1112 fileInfo[0].stat = FILE_STAT_COMPLETE;
1113 fileInfo[0].file = (char *)"file1";
1114 fileInfo[1].stat = FILE_STAT_COMPLETE;
1115 fileInfo[1].file = (char *)"file2";
1116 fileInfo[2].stat = FILE_STAT_COMPLETE;
1117 fileInfo[2].file = (char *)"file3";
1118 msgData.clearPolicyFileList.fileInfo = fileInfo;
1119 int32_t sessionId = TEST_SESSIONID;
1120 DFileMsgType msgType = DFILE_ON_FILE_SEND_SUCCESS;
1121 FileListener* listener = (FileListener *)SoftBusCalloc(sizeof(FileListener));
1122 EXPECT_NE(nullptr, listener);
1123 UdpChannel *channel = TransAddChannelTest();
1124 FileSendErrorEvent(channel, listener, &msgData, msgType, sessionId);
1125 listener->socketSendCallback = MockSocketSendCallback;
1126 listener->socketRecvCallback = MockSocketRecvCallback;
1127
1128 NotifyRecvResult(sessionId, msgType, nullptr, nullptr);
1129
1130 msgType = DFILE_ON_FILE_LIST_RECEIVED;
1131 NotifyRecvResult(sessionId, msgType, &msgData, listener);
1132 msgType = DFILE_ON_FILE_RECEIVE_SUCCESS;
1133 NotifyRecvResult(sessionId, msgType, &msgData, listener);
1134 msgType = DFILE_ON_FILE_RECEIVE_FAIL;
1135 NotifySendResult(sessionId, msgType, &msgData, listener);
1136 msgType = DFILE_ON_TRANS_IN_PROGRESS;
1137 NotifySendResult(sessionId, msgType, &msgData, listener);
1138 msgType = DFILE_ON_BIND;
1139 NotifySendResult(sessionId, msgType, &msgData, listener);
1140
1141 FileRecvErrorEvent(channel, listener, &msgData, msgType, sessionId);
1142 listener->socketSendCallback = nullptr;
1143 FileRecvErrorEvent(channel, listener, &msgData, msgType, sessionId);
1144 SoftBusFree(listener);
1145 SoftBusFree(fileInfo);
1146 }
1147
1148 /**
1149 * @tc.name: FillFileStatusListTest006
1150 * @tc.desc: test fill file status list
1151 * @tc.type: FUNC
1152 * @tc.require:
1153 */
1154 HWTEST_F(TransSdkFileTest, FillFileStatusListTest006, TestSize.Level0)
1155 {
1156 int32_t channelId = TEST_CHANNELID;
1157 uint8_t tos = 1;
1158 RenameHook(nullptr);
1159 int32_t ret = NotifyTransLimitChanged(channelId, tos);
1160 EXPECT_NE(SOFTBUS_OK, ret);
1161 }
1162
1163 /**
1164 * @tc.name: NotifySocketSendResultTest001
1165 * @tc.desc: test notify socket send result
1166 * @tc.type: FUNC
1167 * @tc.require:
1168 */
1169 HWTEST_F(TransSdkFileTest, NotifySocketSendResultTest001, TestSize.Level0)
1170 {
1171 int32_t socket = 1;
1172 DFileMsg msgData;
1173 InitDFileMsg(&msgData);
1174 FileListener listener;
1175 listener.socketSendCallback = MockSocketSendCallback;
1176 listener.socketRecvCallback = MockSocketRecvCallback;
1177
1178 NotifySocketSendResult(socket, DFILE_ON_TRANS_IN_PROGRESS, &msgData, &listener);
1179 NotifySocketSendResult(socket, DFILE_ON_FILE_SEND_SUCCESS, &msgData, &listener);
1180 NotifySocketSendResult(socket, DFILE_ON_FILE_SEND_FAIL, &msgData, &listener);
1181 NotifySocketSendResult(socket, DFILE_ON_CLEAR_POLICY_FILE_LIST, &msgData, &listener);
1182 NotifySocketSendResult(socket, DFILE_ON_CONNECT_FAIL, &msgData, &listener);
1183
1184 NotifySocketRecvResult(socket, DFILE_ON_FILE_LIST_RECEIVED, &msgData, &listener);
1185 NotifySocketRecvResult(socket, DFILE_ON_TRANS_IN_PROGRESS, &msgData, &listener);
1186 NotifySocketRecvResult(socket, DFILE_ON_FILE_RECEIVE_SUCCESS, &msgData, &listener);
1187 NotifySocketRecvResult(socket, DFILE_ON_FILE_RECEIVE_FAIL, &msgData, &listener);
1188 NotifySocketRecvResult(socket, DFILE_ON_CLEAR_POLICY_FILE_LIST, &msgData, &listener);
1189 NotifySocketRecvResult(socket, DFILE_ON_CONNECT_FAIL, &msgData, &listener);
1190 }
1191
1192 /**
1193 * @tc.name: FillFileEventErrorCodeTest
1194 * @tc.desc: test fill file event error code
1195 * @tc.type: FUNC
1196 * @tc.require:
1197 */
1198 HWTEST_F(TransSdkFileTest, FillFileEventErrorCodeTest, TestSize.Level0)
1199 {
1200 DFileMsg msgData;
1201 FileEvent event;
1202
1203 msgData.errorCode = NSTACKX_EOK;
1204 FillFileEventErrorCode(&msgData, &event);
1205 ASSERT_EQ(SOFTBUS_OK, event.errorCode);
1206
1207 msgData.errorCode = NSTACKX_EPERM;
1208 FillFileEventErrorCode(&msgData, &event);
1209 ASSERT_EQ(SOFTBUS_TRANS_FILE_PERMISSION_DENIED, event.errorCode);
1210
1211 msgData.errorCode = NSTACKX_EDQUOT;
1212 FillFileEventErrorCode(&msgData, &event);
1213 ASSERT_EQ(SOFTBUS_TRANS_FILE_DISK_QUOTA_EXCEEDED, event.errorCode);
1214
1215 msgData.errorCode = NSTACKX_ENOMEM;
1216 FillFileEventErrorCode(&msgData, &event);
1217 ASSERT_EQ(SOFTBUS_TRANS_FILE_NO_MEMORY, event.errorCode);
1218
1219 msgData.errorCode = NSTACKX_ENETDOWN;
1220 FillFileEventErrorCode(&msgData, &event);
1221 ASSERT_EQ(SOFTBUS_TRANS_FILE_NETWORK_ERROR, event.errorCode);
1222
1223 msgData.errorCode = NSTACKX_ENOENT;
1224 FillFileEventErrorCode(&msgData, &event);
1225 ASSERT_EQ(SOFTBUS_TRANS_FILE_NOT_FOUND, event.errorCode);
1226
1227 msgData.errorCode = NSTACKX_EEXIST;
1228 FillFileEventErrorCode(&msgData, &event);
1229 ASSERT_EQ(SOFTBUS_TRANS_FILE_EXISTED, event.errorCode);
1230
1231 msgData.errorCode = NSTACKX_NOTSUPPORT;
1232 FillFileEventErrorCode(&msgData, &event);
1233 ASSERT_EQ(NSTACKX_NOTSUPPORT, event.errorCode);
1234 }
1235 }