1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17 #include <sys/types.h>
18 #include <sys/stat.h>
19 #include <fcntl.h>
20 #include "securec.h"
21
22 #include "client_trans_proxy_file_manager.c"
23 #include "client_trans_session_manager.c"
24 #include "client_trans_file_listener.h"
25 #include "softbus_def.h"
26 #include "softbus_errcode.h"
27 #include "softbus_server_frame.h"
28 #include "session.h"
29 #include "softbus_app_info.h"
30 #include "softbus_access_token_test.h"
31
32 #define TEST_FILE_LENGTH 10
33 #define TEST_FILE_CNT 2
34 #define TEST_CHANNEL_ID 2
35 #define TEST_SESSION_ID 1
36 #define TEST_SEQ 1020
37 #define TEST_SEQ_SECOND 2
38 #define TEST_HEADER_LENGTH 24
39 #define TEST_FILE_PATH "/data/file.txt"
40 #define TEST_DATA_LENGTH 6
41 #define TEST_FILE_SIZE 1000
42 #define TEST_PATH_SIZE 50
43 #define TEST_FILE_TEST_TXT_FILE 16
44
45 using namespace std;
46 using namespace testing::ext;
47
48 namespace OHOS {
49 const char *g_pkgName = "dms";
50 const char *g_sessionName = "ohos.distributedschedule.dms.test";
51 const char *g_peerNetworkId = "1234567789";
52 const char *g_groupId = "123";
53 FILE *g_fileTest = NULL;
54 FILE *g_fileSs = NULL;
55 int g_fd = 0;
56 char g_writeData[128] = "test111111111111111111111111111111111111111111111111111111111111";
57 const char *g_rootDir = "/data";
58
59 SessionAttribute g_attr = {
60 .dataType = TYPE_MESSAGE,
61 .linkTypeNum = LINK_TYPE_WIFI_WLAN_5G,
62 };
63
64 SessionParam g_param = {
65 .sessionName = g_sessionName,
66 .peerSessionName = g_sessionName,
67 .peerDeviceId = g_peerNetworkId,
68 .groupId = g_groupId,
69 .attr = &g_attr,
70 };
71
72 const char *g_testProxyFileList[] = {
73 "/data/test.txt",
74 "/data/ss.txt",
75 };
76
77 const char *g_fileList[] = {
78 "/data/data/test.txt",
79 "/path/max/length/512/"
80 "11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
81 "11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
82 "11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
83 "11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
84 "111111111111111111111111111111111111111111111111111",
85 };
86
OnSessionOpened(int sessionId,int result)87 static int OnSessionOpened(int sessionId, int result)
88 {
89 return SOFTBUS_OK;
90 }
91
OnSessionClosed(int sessionId)92 static void OnSessionClosed(int sessionId)
93 {
94 }
95
OnBytesReceived(int sessionId,const void * data,unsigned int len)96 static void OnBytesReceived(int sessionId, const void *data, unsigned int len)
97 {
98 }
99
OnMessageReceived(int sessionId,const void * data,unsigned int len)100 static void OnMessageReceived(int sessionId, const void *data, unsigned int len)
101 {
102 }
103
104 static ISessionListener g_sessionlistener = {
105 .OnSessionOpened = OnSessionOpened,
106 .OnSessionClosed = OnSessionClosed,
107 .OnBytesReceived = OnBytesReceived,
108 .OnMessageReceived = OnMessageReceived,
109 };
110
OnSendFileProcess(int sessionId,uint64_t bytesUpload,uint64_t bytesTotal)111 static int OnSendFileProcess(int sessionId, uint64_t bytesUpload, uint64_t bytesTotal)
112 {
113 return SOFTBUS_OK;
114 }
115
OnSendFileFinished(int sessionId,const char * firstFile)116 static int OnSendFileFinished(int sessionId, const char *firstFile)
117 {
118 return SOFTBUS_OK;
119 }
120
OnFileTransError(int sessionId)121 void OnFileTransError(int sessionId)
122 {
123 return;
124 }
125
OnReceiveFileStarted(int sessionId,const char * files,int fileCnt)126 static int OnReceiveFileStarted(int sessionId, const char *files, int fileCnt)
127 {
128 return SOFTBUS_OK;
129 }
130
OnReceiveFileProcess(int sessionId,const char * firstFile,uint64_t bytesUpload,uint64_t bytesTotal)131 static int OnReceiveFileProcess(int sessionId, const char *firstFile, uint64_t bytesUpload, uint64_t bytesTotal)
132 {
133 return SOFTBUS_OK;
134 }
OnReceiveFileFinished(int sessionId,const char * files,int fileCnt)135 static void OnReceiveFileFinished(int sessionId, const char *files, int fileCnt)
136 {
137 return;
138 }
139
140 const IFileSendListener g_listener = {
141 .OnSendFileProcess = OnSendFileProcess,
142 .OnSendFileFinished = OnSendFileFinished,
143 .OnFileTransError = OnFileTransError,
144 };
145
146 const IFileReceiveListener g_fileRecvListener = {
147 .OnReceiveFileStarted = OnReceiveFileStarted,
148 .OnReceiveFileProcess = OnReceiveFileProcess,
149 .OnReceiveFileFinished = OnReceiveFileFinished,
150 .OnFileTransError = OnFileTransError,
151 };
152
153 class ClientTransProxyFileManagerTest : public testing::Test {
154 public:
ClientTransProxyFileManagerTest()155 ClientTransProxyFileManagerTest() {}
~ClientTransProxyFileManagerTest()156 ~ClientTransProxyFileManagerTest() {}
157 static void SetUpTestCase(void);
158 static void TearDownTestCase(void);
SetUp()159 void SetUp() override {}
TearDown()160 void TearDown() override {}
161 };
162
SetUpTestCase(void)163 void ClientTransProxyFileManagerTest::SetUpTestCase(void)
164 {
165 SetAceessTokenPermission("dsoftbusTransTest");
166 int ret = TransServerProxyInit();
167 EXPECT_EQ(SOFTBUS_OK, ret);
168 g_fileTest = fopen(g_testProxyFileList[0], "w+");
169 EXPECT_NE(g_fileTest, nullptr);
170
171 g_fileSs = fopen(g_testProxyFileList[1], "w+");
172 EXPECT_NE(g_fileSs, nullptr);
173 fprintf(g_fileSs, "%s", "Hello world!\n");
174 g_fd = open(TEST_FILE_PATH, O_RDWR | O_CREAT, S_IRWXU);
175 EXPECT_NE(g_fd, -1);
176 write(g_fd, g_writeData, sizeof(g_writeData));
177 }
178
TearDownTestCase(void)179 void ClientTransProxyFileManagerTest::TearDownTestCase(void)
180 {
181 fclose(g_fileTest);
182 fclose(g_fileSs);
183 close(g_fd);
184 int ret = remove(g_testProxyFileList[0]);
185 EXPECT_EQ(SOFTBUS_OK, ret);
186
187 ret = remove(g_testProxyFileList[1]);
188 EXPECT_EQ(SOFTBUS_OK, ret);
189
190 ret = remove(TEST_FILE_PATH);
191 EXPECT_EQ(SOFTBUS_OK, ret);
192 ClinetTransProxyFileManagerDeinit();
193 }
194
195 /**
196 * @tc.name: ClinetTransProxySendFileTest001
197 * @tc.desc: client trans proxy send file test, use the wrong parameter.
198 * @tc.type: FUNC
199 * @tc.require:
200 */
201 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxySendFileTest001, TestSize.Level0)
202 {
203 int32_t channelId = 1;
204 int ret = ProxyChannelSendFile(channelId, g_testProxyFileList, g_testProxyFileList, 0);
205 EXPECT_EQ(SOFTBUS_ERR, ret);
206
207 ret = ProxyChannelSendFile(channelId, nullptr, g_testProxyFileList, TEST_FILE_CNT);
208 EXPECT_EQ(SOFTBUS_ERR, ret);
209
210 const char *proxyNullFileList[] = {
211 nullptr,
212 "/path/max/length/512",
213 };
214 ret = ProxyChannelSendFile(channelId, proxyNullFileList, g_testProxyFileList, TEST_FILE_CNT);
215 EXPECT_EQ(SOFTBUS_ERR, ret);
216
217 const char *proxyZeroLileList[] = {
218 "",
219 "/path/max/length/512",
220 };
221 ret = ProxyChannelSendFile(channelId, proxyZeroLileList, g_testProxyFileList, TEST_FILE_CNT);
222 EXPECT_EQ(SOFTBUS_ERR, ret);
223
224 const char *proxyLengthFileList[] = {
225 "/path/max/length/512",
226 "/path/max/length/512/"
227 "11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
228 "11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
229 "11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
230 "11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
231 "111111111111111111111111111111111111111111111111111",
232 };
233 ret = ProxyChannelSendFile(channelId, proxyLengthFileList, g_testProxyFileList, TEST_FILE_CNT);
234 EXPECT_EQ(SOFTBUS_ERR, ret);
235
236 ret = ProxyChannelSendFile(channelId, g_testProxyFileList, nullptr, TEST_FILE_CNT);
237 EXPECT_EQ(SOFTBUS_ERR, ret);
238
239 ret = ProxyChannelSendFile(channelId, g_testProxyFileList, proxyNullFileList, TEST_FILE_CNT);
240 EXPECT_EQ(SOFTBUS_ERR, ret);
241
242 ret = ProxyChannelSendFile(channelId, g_testProxyFileList, g_testProxyFileList, TEST_FILE_CNT);
243 EXPECT_EQ(SOFTBUS_LOCK_ERR, ret);
244 }
245
246 /**
247 * @tc.name: ClinetTransRecvFileFrameDataTest001
248 * @tc.desc: clent trans recv file frame data test, use the wrong parameter.
249 * @tc.type: FUNC
250 * @tc.require:
251 */
252 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransRecvFileFrameDataTest001, TestSize.Level0)
253 {
254 int32_t channelId = 1;
255 int32_t sessionId = 1;
256 int ret = ProcessRecvFileFrameData(sessionId, channelId, nullptr);
257 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
258
259 FileFrame fileFrame;
260 fileFrame.frameLength = PROXY_MAX_PACKET_SIZE + 1;
261 ret = ProcessRecvFileFrameData(sessionId, channelId, &fileFrame);
262 EXPECT_EQ(SOFTBUS_ERR, ret);
263
264 fileFrame.frameType = TRANS_SESSION_FILE_FIRST_FRAME;
265 ret = ProcessRecvFileFrameData(sessionId, channelId, &fileFrame);
266 EXPECT_EQ(SOFTBUS_ERR, ret);
267 }
268
269 /**
270 * @tc.name: ClinetTransRecvFileFrameDataTest002
271 * @tc.desc: client trans recv file frame data test, use the wrong parameter.
272 * @tc.type: FUNC
273 * @tc.require:
274 */
275 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransRecvFileFrameDataTest002, TestSize.Level0)
276 {
277 int32_t channelId = 1;
278 int32_t sessionId = 1;
279
280 FileFrame fileFrame;
281 fileFrame.frameLength = PROXY_MAX_PACKET_SIZE - 1;
282
283 fileFrame.frameType = TRANS_SESSION_FILE_FIRST_FRAME;
284 int ret = ProcessRecvFileFrameData(sessionId, channelId, &fileFrame);
285 EXPECT_EQ(SOFTBUS_ERR, ret);
286
287 fileFrame.frameType = TRANS_SESSION_FILE_ONGOINE_FRAME;
288 ret = ProcessRecvFileFrameData(sessionId, channelId, &fileFrame);
289 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
290
291 fileFrame.frameType = TRANS_SESSION_FILE_ONLYONE_FRAME;
292 ret = ProcessRecvFileFrameData(sessionId, channelId, &fileFrame);
293 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
294
295 fileFrame.frameType = TRANS_SESSION_FILE_LAST_FRAME;
296 ret = ProcessRecvFileFrameData(sessionId, channelId, &fileFrame);
297 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
298
299 fileFrame.frameType = TRANS_SESSION_FILE_ACK_REQUEST_SENT;
300 ret = ProcessRecvFileFrameData(sessionId, channelId, &fileFrame);
301 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
302
303 fileFrame.frameType = TRANS_SESSION_FILE_ACK_RESPONSE_SENT;
304 ret = ProcessRecvFileFrameData(sessionId, channelId, &fileFrame);
305 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
306
307 fileFrame.frameType = TRANS_SESSION_FILE_CRC_CHECK_FRAME;
308 ret = ProcessRecvFileFrameData(sessionId, channelId, &fileFrame);
309 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
310
311 fileFrame.frameType = TRANS_SESSION_FILE_RESULT_FRAME;
312 ret = ProcessRecvFileFrameData(sessionId, channelId, &fileFrame);
313 EXPECT_EQ(SOFTBUS_ERR, ret);
314
315 fileFrame.frameType = TRANS_SESSION_FILE_ALLFILE_SENT;
316 ret = ProcessRecvFileFrameData(sessionId, channelId, &fileFrame);
317 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
318
319 fileFrame.frameType = -1;
320 ret = ProcessRecvFileFrameData(sessionId, channelId, &fileFrame);
321 EXPECT_EQ(SOFTBUS_ERR, ret);
322 }
323
324 /**
325 * @tc.name: ClinetTransProxyFileManagerInitDataTest001
326 * @tc.desc: client trans proxy file manager init data test, use the wrong or normal parameter.
327 * @tc.type: FUNC
328 * @tc.require:
329 */
330 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyFileManagerInitDataTest001, TestSize.Level0)
331 {
332 int32_t ret = ClinetTransProxyFileManagerInit();
333 EXPECT_EQ(SOFTBUS_OK, ret);
334
335 int32_t channelId = 1;
336 uint32_t seq = TEST_SEQ;
337 int32_t result = 0;
338 uint32_t side = 0;
339 ret = SendFileTransResult(channelId, seq, result, side);
340 EXPECT_EQ(SOFTBUS_ERR, ret);
341
342 uint32_t data = 0;
343 const uint8_t *data1 = (const uint8_t *)&data;
344 uint32_t len = TEST_HEADER_LENGTH;
345 ret = UnpackFileTransResultFrame(data1, len, nullptr, &result, &side);
346 EXPECT_EQ(SOFTBUS_ERR, ret);
347
348 ret = UnpackFileTransResultFrame(nullptr, len, &seq, &result, &side);
349 EXPECT_NE(SOFTBUS_OK, ret);
350
351 ret = UnpackFileTransResultFrame(data1, len, &seq, &result, &side);
352 EXPECT_NE(SOFTBUS_OK, ret);
353
354 data = FILE_MAGIC_NUMBER;
355 const uint8_t *data2 = (const uint8_t *)&data;
356 ret = UnpackFileTransResultFrame(data2, len, &seq, &result, &side);
357 EXPECT_NE(SOFTBUS_OK, ret);
358 }
359
360 /**
361 * @tc.name: ClinetTransProxyGetSessionFileLockTest001
362 * @tc.desc: client trans proxy get session file lock test, use the wrong or normal parameter.
363 * @tc.type: FUNC
364 * @tc.require:
365 */
366 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyGetSessionFileLockTest001, TestSize.Level0)
367 {
368 int32_t channelId = 1;
369 ProxyFileMutexLock *sessionLock = GetSessionFileLock(channelId);
370 EXPECT_NE(nullptr, sessionLock);
371
372 DelSessionFileLock(nullptr);
373 sessionLock->count = 1;
374 DelSessionFileLock(sessionLock);
375
376 sessionLock->count = 2;
377 DelSessionFileLock(sessionLock);
378 }
379
380 /**
381 * @tc.name: ClinetTransProxyCreateSendListenerInfoTest001
382 * @tc.desc: client trans proxy create send listener info test, use the wrong or normal parameter.
383 * @tc.type: FUNC
384 * @tc.require:
385 */
386 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyCreateSendListenerInfoTest001, TestSize.Level0)
387 {
388 int ret = CreateSessionServer(g_pkgName, g_sessionName, &g_sessionlistener);
389 ASSERT_EQ(SOFTBUS_OK, ret);
390
391 int32_t sessionId = 1;
392 bool isEnabled = false;
393
394 ret = ClientAddSession(&g_param, &sessionId, &isEnabled);
395 ASSERT_EQ(SOFTBUS_OK, ret);
396
397 SendListenerInfo *sendListenerInfo;
398 ret = CreateSendListenerInfo(&sendListenerInfo, TEST_CHANNEL_ID);
399 EXPECT_EQ(SOFTBUS_ERR, ret);
400
401 int32_t channelId = 1;
402 SessionInfo sessionInfo;
403 sessionInfo.sessionId = sessionId;
404 sessionInfo.channelId = channelId;
405 sessionInfo.channelType = CHANNEL_TYPE_PROXY;
406 ret = AddSession(g_sessionName, &sessionInfo);
407 ASSERT_EQ(SOFTBUS_OK, ret);
408
409 ret = TransSetFileSendListener(g_sessionName, &g_listener);
410 ASSERT_EQ(SOFTBUS_OK, ret);
411
412 ret = TransSetFileReceiveListener(g_sessionName, &g_fileRecvListener, g_rootDir);
413 ASSERT_EQ(SOFTBUS_OK, ret);
414
415 ret = CreateSendListenerInfo(&sendListenerInfo, channelId);
416 EXPECT_EQ(SOFTBUS_OK, ret);
417
418 ret = CreateSendListenerInfo(&sendListenerInfo, channelId);
419 EXPECT_EQ(SOFTBUS_ALREADY_EXISTED, ret);
420
421 ret = AddSendListenerInfo(nullptr);
422 EXPECT_NE(SOFTBUS_OK, ret);
423 }
424
425 /**
426 * @tc.name: ClinetTransProxyFileToFrameTest001
427 * @tc.desc: client trans proxy send file test, use the wrong or normal parameter.
428 * @tc.type: FUNC
429 * @tc.require:
430 */
431 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyFileToFrameTest001, TestSize.Level0)
432 {
433 SendListenerInfo info;
434 info.sessionId = 1;
435 info.crc = 1;
436 info.channelId = 1;
437
438 int ret = SendSingleFile(&info, nullptr, g_testProxyFileList[0]);
439 EXPECT_EQ(SOFTBUS_ERR, ret);
440
441 ret = FileToFrameAndSendFile(nullptr, g_testProxyFileList[0], g_testProxyFileList[0]);
442 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
443
444 ret = FileToFrameAndSendFile(&info, g_testProxyFileList[0], nullptr);
445 EXPECT_EQ(SOFTBUS_ERR, ret);
446
447 ret = FileToFrameAndSendFile(&info, nullptr, g_testProxyFileList[0]);
448 EXPECT_EQ(SOFTBUS_ERR, ret);
449
450 ret = FileToFrameAndSendFile(&info, g_testProxyFileList[0], g_testProxyFileList[0]);
451 EXPECT_EQ(SOFTBUS_ERR, ret);
452
453 ret = SendSingleFile(&info, g_testProxyFileList[0], g_testProxyFileList[0]);
454 EXPECT_EQ(SOFTBUS_ERR, ret);
455
456 ret = SendFileList(info.channelId, g_testProxyFileList, TEST_FILE_CNT);
457 EXPECT_EQ(SOFTBUS_ERR, ret);
458
459 ret = SendFileList(info.channelId, nullptr, TEST_FILE_CNT);
460 EXPECT_EQ(SOFTBUS_ERR, ret);
461 }
462
463 /**
464 * @tc.name: ClinetTransProxyGetAndCheckFileSizeTest001
465 * @tc.desc: improve branch coverage, use the wrong or normal parameter.
466 * @tc.type: FUNC
467 * @tc.require:
468 */
469 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyGetAndCheckFileSizeTest001, TestSize.Level0)
470 {
471 uint64_t fileSize = 0;
472 uint64_t frameNum = 0;
473 int ret = GetAndCheckFileSize(nullptr, &fileSize, &frameNum, APP_INFO_FILE_FEATURES_SUPPORT);
474 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
475
476 ret = GetAndCheckFileSize(g_testProxyFileList[0], &fileSize, &frameNum, APP_INFO_FILE_FEATURES_SUPPORT);
477 EXPECT_EQ(SOFTBUS_OK, ret);
478
479 ret = GetAndCheckFileSize(g_testProxyFileList[1], &fileSize, &frameNum, APP_INFO_FILE_FEATURES_NO_SUPPORT);
480 EXPECT_EQ(SOFTBUS_OK, ret);
481 }
482
483 /**
484 * @tc.name: ClinetTransProxySendOneFrameTest001
485 * @tc.desc: client trans proxy send one frame test, use the wrong or normal parameter.
486 * @tc.type: FUNC
487 * @tc.require:
488 */
489 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxySendOneFrameTest001, TestSize.Level0)
490 {
491 SendListenerInfo info;
492 info.sessionId = TEST_SESSION_ID;
493 info.crc = APP_INFO_FILE_FEATURES_SUPPORT;
494 info.channelId = TEST_CHANNEL_ID;
495
496 FileFrame fileFrame = {
497 .frameType = TRANS_SESSION_BYTES,
498 .data = nullptr,
499 };
500 int ret = SendOneFrame(nullptr, &fileFrame);
501 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
502
503 ret = SendOneFrame(&info, &fileFrame);
504 EXPECT_EQ(SOFTBUS_ERR, ret);
505
506 info.crc = APP_INFO_FILE_FEATURES_NO_SUPPORT;
507 uint32_t dataTest = TEST_DATA_LENGTH;
508 fileFrame.data = (uint8_t *)&dataTest;
509 ret = SendOneFrame(&info, &fileFrame);
510 EXPECT_EQ(SOFTBUS_ERR, ret);
511
512 fileFrame.frameType = TRANS_SESSION_FILE_FIRST_FRAME;
513 ret = SendOneFrame(&info, &fileFrame);
514 EXPECT_EQ(SOFTBUS_ERR, ret);
515
516 ret = SendOneFrameFront(nullptr, fileFrame.frameType);
517 EXPECT_NE(SOFTBUS_OK, ret);
518
519 SendListenerInfo infoMiddle;
520 infoMiddle.sessionId = 1;
521 infoMiddle.channelId = 1;
522 infoMiddle.crc = APP_INFO_FILE_FEATURES_NO_SUPPORT;
523 ret = SendOneFrameMiddle(nullptr, TRANS_SESSION_FILE_ONGOINE_FRAME);
524 EXPECT_NE(SOFTBUS_OK, ret);
525
526 ret = SendOneFrameMiddle(&infoMiddle, TRANS_SESSION_FILE_ONGOINE_FRAME);
527 EXPECT_EQ(SOFTBUS_OK, ret);
528
529 ret = SendOneFrameFront(&infoMiddle, TRANS_SESSION_FILE_ONGOINE_FRAME);
530 EXPECT_EQ(SOFTBUS_OK, ret);
531
532 infoMiddle.crc = APP_INFO_FILE_FEATURES_SUPPORT;
533 infoMiddle.seq = 0;
534 ret = SendOneFrameMiddle(&infoMiddle, TRANS_SESSION_BYTES);
535 EXPECT_EQ(SOFTBUS_OK, ret);
536
537 ret = SendOneFrameMiddle(&infoMiddle, TRANS_SESSION_FILE_ONGOINE_FRAME);
538 EXPECT_EQ(SOFTBUS_ERR, ret);
539
540 ret = SendOneFrameFront(&infoMiddle, TRANS_SESSION_FILE_ONGOINE_FRAME);
541 EXPECT_EQ(SOFTBUS_OK, ret);
542
543 ret = SendOneFrameFront(&infoMiddle, TRANS_SESSION_FILE_FIRST_FRAME);
544 EXPECT_EQ(SOFTBUS_OK, ret);
545
546 infoMiddle.seq = TEST_SEQ;
547 ret = SendOneFrameMiddle(&infoMiddle, TRANS_SESSION_FILE_ONGOINE_FRAME);
548 EXPECT_EQ(SOFTBUS_OK, ret);
549 }
550
551 /**
552 * @tc.name: ClinetTransProxySendOneFrameTest002
553 * @tc.desc: client trans proxy send one frame test, use the wrong or normal parameter.
554 * @tc.type: FUNC
555 * @tc.require:
556 */
557 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxySendOneFrameTest002, TestSize.Level0)
558 {
559 SendListenerInfo infoRear;
560 infoRear.sessionId = 1;
561 infoRear.channelId = 1;
562 infoRear.crc = APP_INFO_FILE_FEATURES_NO_SUPPORT;
563 int ret = SendOneFrameRear(nullptr, TRANS_SESSION_BYTES);
564 EXPECT_NE(SOFTBUS_OK, ret);
565
566 ret = SendOneFrameRear(&infoRear, TRANS_SESSION_BYTES);
567 EXPECT_EQ(SOFTBUS_OK, ret);
568
569 infoRear.crc = APP_INFO_FILE_FEATURES_SUPPORT;
570 ret = SendOneFrameRear(&infoRear, TRANS_SESSION_FILE_ONLYONE_FRAME);
571 EXPECT_EQ(SOFTBUS_OK, ret);
572
573 ret = SendOneFrameRear(&infoRear, TRANS_SESSION_FILE_FIRST_FRAME);
574 EXPECT_EQ(SOFTBUS_ERR, ret);
575
576 infoRear.waitSeq = 0;
577 ret = SendOneFrameRear(&infoRear, TRANS_SESSION_FILE_LAST_FRAME);
578 EXPECT_EQ(SOFTBUS_OK, ret);
579
580 infoRear.waitSeq = TEST_SEQ;
581 ret = SendOneFrameRear(&infoRear, TRANS_SESSION_FILE_LAST_FRAME);
582 EXPECT_EQ(SOFTBUS_ERR, ret);
583 }
584
585 /**
586 * @tc.name: ClinetTransProxyFileRecipientInfoTest001
587 * @tc.desc: client trans proxy file recipient info test, use the wrong or normal parameter.
588 * @tc.type: FUNC
589 * @tc.require:
590 */
591 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyFileRecipientInfoTest001, TestSize.Level0)
592 {
593 FileRecipientInfo info;
594 info.recvFileInfo.fileFd = -2;
595 info.recvState = TRANS_FILE_RECV_ERR_STATE;
596 info.crc = APP_INFO_FILE_FEATURES_SUPPORT;
597 info.channelId = 1;
598 info.recvFileInfo.seq = TEST_SEQ;
599 info.fileListener.recvListener.OnFileTransError = nullptr;
600 ClearRecipientResources(&info);
601
602 info.fileListener.recvListener.OnFileTransError = OnFileTransError;
603 SetRecipientRecvState(&info, TRANS_FILE_RECV_IDLE_STATE);
604 ClearRecipientResources(&info);
605
606 info.crc = APP_INFO_FILE_FEATURES_NO_SUPPORT;
607 ClearRecipientResources(&info);
608
609 info.recvState = TRANS_FILE_RECV_IDLE_STATE;
610 SetRecipientRecvState(&info, TRANS_FILE_RECV_IDLE_STATE);
611 SetRecipientRecvState(&info, TRANS_FILE_RECV_PROCESS_STATE);
612 ClearRecipientResources(&info);
613
614 info.recvFileInfo.fileFd = INVALID_FD;
615 ClearRecipientResources(&info);
616 }
617
618 /**
619 * @tc.name: ClinetTransProxyFileAckReqAndResDataTest001
620 * @tc.desc: client trans proxy file ack req and res data test, use the wrong or normal parameter.
621 * @tc.type: FUNC
622 * @tc.require:
623 */
624 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyFileAckReqAndResDataTest001, TestSize.Level0)
625 {
626 int32_t channelId = 1;
627 uint32_t startSeq = TEST_SEQ;
628 uint32_t value = 0;
629 int ret = SendFileAckReqAndResData(channelId, startSeq, value, CHANNEL_TYPE_PROXY);
630 EXPECT_EQ(SOFTBUS_ERR, ret);
631
632 FileFrame frame;
633 frame.frameLength = 0;
634 frame.data = nullptr;
635 uint32_t dataTest = 0;
636 ret = UnpackAckReqAndResData(nullptr, &startSeq, &value);
637 EXPECT_NE(SOFTBUS_OK, ret);
638
639 ret = UnpackAckReqAndResData(&frame, &startSeq, &value);
640 EXPECT_NE(SOFTBUS_OK, ret);
641
642 frame.data = (uint8_t *)&dataTest;
643 ret = UnpackAckReqAndResData(&frame, &startSeq, &value);
644 EXPECT_NE(SOFTBUS_OK, ret);
645
646 frame.frameLength = TEST_HEADER_LENGTH;
647 ret = UnpackAckReqAndResData(&frame, &startSeq, &value);
648 EXPECT_NE(SOFTBUS_OK, ret);
649
650 dataTest = FILE_MAGIC_NUMBER;
651 frame.data = (uint8_t *)&dataTest;
652 ret = UnpackAckReqAndResData(&frame, &startSeq, &value);
653 EXPECT_EQ(SOFTBUS_OK, ret);
654 }
655
656 /**
657 * @tc.name: ClinetTransProxyPackFileDataTest001
658 * @tc.desc: client trans proxy pack file data test, use the wrong parameter.
659 * @tc.type: FUNC
660 * @tc.require:
661 */
662 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyPackFileDataTest001, TestSize.Level0)
663 {
664 FileFrame fileFrame = {
665 .frameType = TRANS_SESSION_BYTES,
666 .data = nullptr,
667 };
668 uint64_t readLength = TEST_FILE_LENGTH;
669 uint64_t fileOffset = 0;
670 SendListenerInfo info;
671 info.fd = g_fd;
672 uint32_t seq = TEST_SEQ;
673 int64_t len = PackReadFileData(&fileFrame, readLength, fileOffset, &info);
674 EXPECT_EQ(SOFTBUS_ERR, len);
675
676 len = PackReadFileRetransData(&fileFrame, seq, readLength, fileOffset, &info);
677 EXPECT_EQ(SOFTBUS_ERR, len);
678
679 uint32_t dataTest = TEST_DATA_LENGTH;
680 fileFrame.data = (uint8_t *)&dataTest;
681 fileFrame.fileData = (uint8_t *)&dataTest;
682 len = PackReadFileData(&fileFrame, readLength, fileOffset, &info);
683 EXPECT_NE(SOFTBUS_ERR, len);
684
685 len = PackReadFileRetransData(&fileFrame, seq, readLength, fileOffset, &info);
686 EXPECT_EQ(SOFTBUS_ERR, len);
687 }
688
689 /**
690 * @tc.name: ClinetTransProxyPackFileDataFrameTest001
691 * @tc.desc: client trans proxy pack file data frame test, use normal parameter.
692 * @tc.type: FUNC
693 * @tc.require:
694 */
695 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyPackFileDataFrameTest001, TestSize.Level0)
696 {
697 uint32_t dataTest = TEST_DATA_LENGTH;
698 FileFrame fileFrame = {
699 .magic = FILE_MAGIC_NUMBER,
700 .frameType = TRANS_SESSION_BYTES,
701 .frameLength = 0,
702 .data = (uint8_t *)&dataTest,
703 .fileData = (uint8_t *)&dataTest,
704 };
705
706 FileRecipientInfo info = {
707 .crc = APP_INFO_FILE_FEATURES_NO_SUPPORT,
708 };
709
710 uint32_t fileDataLen = 0;
711 int ret = UnpackFileDataFrame(&info, &fileFrame, &fileDataLen);
712 EXPECT_NE(SOFTBUS_OK, ret);
713
714 fileFrame.frameLength = TEST_HEADER_LENGTH;
715 ret = UnpackFileDataFrame(&info, &fileFrame, &fileDataLen);
716 EXPECT_EQ(SOFTBUS_OK, ret);
717
718 info.crc = APP_INFO_FILE_FEATURES_SUPPORT;
719 ret = UnpackFileDataFrame(&info, &fileFrame, &fileDataLen);
720 EXPECT_NE(SOFTBUS_OK, ret);
721
722 fileFrame.magic = 0;
723 ret = UnpackFileDataFrame(&info, &fileFrame, &fileDataLen);
724 EXPECT_NE(SOFTBUS_OK, ret);
725 }
726
727 /**
728 * @tc.name: ClinetTransProxyRetransFileFrameTest001
729 * @tc.desc: client trans proxy retrans file frame test, use normal parameter.
730 * @tc.type: FUNC
731 * @tc.require:
732 */
733 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyRetransFileFrameTest001, TestSize.Level0)
734 {
735 SendListenerInfo info = {
736 .fileSize = TEST_FILE_SIZE,
737 .crc = APP_INFO_FILE_FEATURES_NO_SUPPORT,
738 };
739 int ret = RetransFileFrameBySeq(nullptr, TEST_SEQ);
740 EXPECT_NE(SOFTBUS_OK, ret);
741
742 ret = RetransFileFrameBySeq(&info, TEST_SEQ);
743 EXPECT_EQ(SOFTBUS_OK, ret);
744
745 info.crc = APP_INFO_FILE_FEATURES_SUPPORT;
746 int32_t seq = TEST_SEQ_SECOND;
747 ret = RetransFileFrameBySeq(&info, seq);
748 EXPECT_NE(SOFTBUS_OK, ret);
749
750 ret = RetransFileFrameBySeq(&info, TEST_SEQ);
751 EXPECT_NE(SOFTBUS_OK, ret);
752 }
753
754 /**
755 * @tc.name: ClinetTransProxyAckResponseDataHandleTest001
756 * @tc.desc: client trans proxy handle response data test, use normal parameter.
757 * @tc.type: FUNC
758 * @tc.require:
759 */
760 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyAckResponseDataHandleTest001, TestSize.Level0)
761 {
762 SendListenerInfo info = {
763 .fileSize = TEST_FILE_SIZE,
764 .crc = APP_INFO_FILE_FEATURES_NO_SUPPORT,
765 };
766 uint32_t len = 0;
767 int ret = AckResponseDataHandle(&info, nullptr, len);
768 EXPECT_EQ(SOFTBUS_OK, ret);
769
770 const char *data = "test_data";
771 ret = AckResponseDataHandle(&info, data, len);
772 EXPECT_EQ(SOFTBUS_OK, ret);
773
774 len = sizeof(AckResponseData);
775 ret = AckResponseDataHandle(&info, data, len);
776 EXPECT_EQ(SOFTBUS_OK, ret);
777
778 AckResponseData ackResponseData = {
779 .startSeq = FILE_SEND_ACK_RESULT_SUCCESS,
780 .seqResult = TEST_SEQ_SECOND,
781 };
782 const char *dataTest = reinterpret_cast<const char*>(&ackResponseData);
783 ret = AckResponseDataHandle(&info, dataTest, len);
784 EXPECT_EQ(SOFTBUS_OK, ret);
785 }
786
787 /**
788 * @tc.name: ClinetTransProxyGetFullRecvPathTest001
789 * @tc.desc: client trans proxy get full recv path test, use normal parameter.
790 * @tc.type: FUNC
791 * @tc.require:
792 */
793 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyGetFullRecvPathTest001, TestSize.Level0)
794 {
795 char *result = GetFullRecvPath(nullptr, nullptr);
796 EXPECT_EQ(nullptr, result);
797 const char *filePath1 = "";
798 const char *recvRootDir1 = "";
799
800 result = GetFullRecvPath(filePath1, recvRootDir1);
801 EXPECT_NE(nullptr, result);
802
803 const char *filePath2 = "/test.txt";
804 result = GetFullRecvPath(filePath2, recvRootDir1);
805 EXPECT_NE(nullptr, result);
806
807 const char *recvRootDir2 = "/data/";
808 result = GetFullRecvPath(filePath1, recvRootDir2);
809 EXPECT_NE(nullptr, result);
810
811 result = GetFullRecvPath(filePath2, recvRootDir2);
812 EXPECT_NE(nullptr, result);
813
814 const char *filePath3 = "/test.txt";
815 const char *recvRootDir3 = "/data";
816 result = GetFullRecvPath(filePath3, recvRootDir2);
817 EXPECT_NE(nullptr, result);
818
819 result = GetFullRecvPath(filePath2, recvRootDir3);
820 EXPECT_NE(nullptr, result);
821 }
822
823 /**
824 * @tc.name: ClinetTransProxyGetDirPathTest001
825 * @tc.desc: client trans proxy get dir path test, use normal parameter.
826 * @tc.type: FUNC
827 * @tc.require:
828 */
829 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyGetDirPathTest001, TestSize.Level0)
830 {
831 int ret = GetDirPath(nullptr, nullptr, 0);
832 EXPECT_NE(SOFTBUS_OK, ret);
833
834 const char *fullPath1 = "";
835 char dirPath1[TEST_FILE_LENGTH] = {0};
836 ret = GetDirPath(fullPath1, nullptr, 0);
837 EXPECT_NE(SOFTBUS_OK, ret);
838
839 const char *fullPath2 = "/data/txt/";
840 ret = GetDirPath(fullPath2, nullptr, 0);
841 EXPECT_NE(SOFTBUS_OK, ret);
842
843 const char *fullPath3 = "/d/t.txt";
844 ret = GetDirPath(fullPath3, dirPath1, 0);
845 EXPECT_NE(SOFTBUS_OK, ret);
846
847 ret = GetDirPath(fullPath3, dirPath1, TEST_FILE_LENGTH);
848 EXPECT_EQ(SOFTBUS_OK, ret);
849 }
850
851 /**
852 * @tc.name: ClinetTransProxyGetAbsFullPathTest001
853 * @tc.desc: client trans proxy get path test, use normal parameter.
854 * @tc.type: FUNC
855 * @tc.require:
856 */
857 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyGetAbsFullPathTest001, TestSize.Level0)
858 {
859 int ret = GetAbsFullPath(nullptr, nullptr, 0);
860 EXPECT_NE(SOFTBUS_OK, ret);
861
862 char recvAbsPath[TEST_PATH_SIZE];
863 ret = GetAbsFullPath(g_testProxyFileList[0], recvAbsPath, TEST_PATH_SIZE);
864 EXPECT_EQ(SOFTBUS_OK, ret);
865
866 ret = GetAbsFullPath(g_testProxyFileList[0], recvAbsPath, TEST_FILE_LENGTH);
867 EXPECT_NE(SOFTBUS_OK, ret);
868
869 ret = CreateDirAndGetAbsPath(g_testProxyFileList[0], nullptr, TEST_PATH_SIZE);
870 EXPECT_NE(SOFTBUS_OK, ret);
871
872 ret = CreateDirAndGetAbsPath(g_testProxyFileList[0], recvAbsPath, TEST_PATH_SIZE);
873 EXPECT_EQ(SOFTBUS_OK, ret);
874
875 ret = CreateDirAndGetAbsPath(g_testProxyFileList[0], recvAbsPath, TEST_FILE_LENGTH);
876 EXPECT_NE(SOFTBUS_OK, ret);
877 }
878
879 /**
880 * @tc.name: ClinetTransProxySendListenerInfoTest001
881 * @tc.desc: client trans proxy add and del SendListenerInfo test, use normal parameter.
882 * @tc.type: FUNC
883 * @tc.require:
884 */
885 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxySendListenerInfoTest001, TestSize.Level0)
886 {
887 SendListenerInfo info;
888 info.sessionId = 1;
889 info.crc = 1;
890 info.channelId = 1;
891 int ret = AddSendListenerInfo(&info);
892 EXPECT_EQ(SOFTBUS_OK, ret);
893
894 DelSendListenerInfo(nullptr);
895
896 DelSendListenerInfo(&info);
897 }
898
899 /**
900 * @tc.name: ClinetTransProxyFileTransStartInfoTest001
901 * @tc.desc: client trans proxy pack file start info test, use normal parameter.
902 * @tc.type: FUNC
903 * @tc.require:
904 */
905 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyFileTransStartInfoTest001, TestSize.Level0)
906 {
907 int ret = PackFileTransStartInfo(nullptr, nullptr, TEST_FILE_TEST_TXT_FILE, nullptr);
908 EXPECT_NE(SOFTBUS_OK, ret);
909
910 uint32_t dataTest = TEST_DATA_LENGTH;
911 FileFrame fileFrame = {
912 .frameLength = 0,
913 .data = (uint8_t *)&dataTest,
914 .fileData = (uint8_t *)&dataTest,
915 };
916 SendListenerInfo info;
917 info.crc = APP_INFO_FILE_FEATURES_SUPPORT;
918 info.sessionId = 1;
919 info.channelId = 1;
920
921 ret = PackFileTransStartInfo(&fileFrame, g_testProxyFileList[0], TEST_FILE_TEST_TXT_FILE, &info);
922 EXPECT_EQ(SOFTBUS_OK, ret);
923
924 info.crc = APP_INFO_FILE_FEATURES_NO_SUPPORT;
925 ret = PackFileTransStartInfo(&fileFrame, g_testProxyFileList[0], TEST_FILE_TEST_TXT_FILE, &info);
926 EXPECT_EQ(SOFTBUS_OK, ret);
927 }
928
929 /**
930 * @tc.name: ClinetTransProxyUnFileTransStartInfoTest001
931 * @tc.desc: client trans proxy pack file data frame test, use normal parameter.
932 * @tc.type: FUNC
933 * @tc.require:
934 */
935 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyUnFileTransStartInfoTest001, TestSize.Level0)
936 {
937 int ret = UnpackFileTransStartInfo(nullptr, nullptr, nullptr);
938 EXPECT_NE(SOFTBUS_OK, ret);
939
940 uint32_t dataTest = TEST_DATA_LENGTH;
941 FileFrame fileFrame = {
942 .frameLength = 0,
943 .data = (uint8_t *)&dataTest,
944 .fileData = (uint8_t *)&dataTest,
945 };
946 FileRecipientInfo info;
947 info.crc = APP_INFO_FILE_FEATURES_SUPPORT;
948 SingleFileInfo singleFileInfo;
949 ret = UnpackFileTransStartInfo(&fileFrame, &info, &singleFileInfo);
950 EXPECT_NE(SOFTBUS_OK, ret);
951
952 fileFrame.frameLength = TEST_HEADER_LENGTH;
953 ret = UnpackFileTransStartInfo(&fileFrame, &info, &singleFileInfo);
954 EXPECT_NE(SOFTBUS_OK, ret);
955
956 uint32_t data = FILE_MAGIC_NUMBER;
957 fileFrame.data = (uint8_t *)&data;
958 ret = UnpackFileTransStartInfo(&fileFrame, &info, &singleFileInfo);
959 EXPECT_NE(SOFTBUS_OK, ret);
960
961 info.crc = APP_INFO_FILE_FEATURES_NO_SUPPORT;
962 fileFrame.frameLength = 0;
963 ret = UnpackFileTransStartInfo(&fileFrame, &info, &singleFileInfo);
964 EXPECT_NE(SOFTBUS_OK, ret);
965
966 fileFrame.frameLength = FRAME_DATA_SEQ_OFFSET;
967 ret = UnpackFileTransStartInfo(&fileFrame, &info, &singleFileInfo);
968 EXPECT_EQ(SOFTBUS_OK, ret);
969
970 fileFrame.frameLength = FRAME_DATA_SEQ_OFFSET + TEST_HEADER_LENGTH;
971 ret = UnpackFileTransStartInfo(&fileFrame, &info, &singleFileInfo);
972 EXPECT_EQ(SOFTBUS_OK, ret);
973 }
974
975 /**
976 * @tc.name: ClinetTransProxyFileCrcCheckSumTest001
977 * @tc.desc: client trans proxy crc check test, use normal parameter.
978 * @tc.type: FUNC
979 * @tc.require:
980 */
981 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyFileCrcCheckSumTest001, TestSize.Level0)
982 {
983 int ret = SendFileCrcCheckSum(nullptr);
984 EXPECT_NE(SOFTBUS_OK, ret);
985
986 SendListenerInfo info;
987 info.crc = APP_INFO_FILE_FEATURES_NO_SUPPORT;
988 ret = SendFileCrcCheckSum(&info);
989 EXPECT_EQ(SOFTBUS_OK, ret);
990
991 info.crc = APP_INFO_FILE_FEATURES_SUPPORT;
992 ret = SendFileCrcCheckSum(&info);
993 EXPECT_NE(SOFTBUS_OK, ret);
994
995 ret = UnpackFileCrcCheckSum(nullptr, nullptr);
996 EXPECT_NE(SOFTBUS_OK, ret);
997
998 FileRecipientInfo fileInfo;
999 fileInfo.crc = APP_INFO_FILE_FEATURES_NO_SUPPORT;
1000 FileFrame fileFrame;
1001 ret = UnpackFileCrcCheckSum(&fileInfo, &fileFrame);
1002 EXPECT_EQ(SOFTBUS_OK, ret);
1003
1004 fileInfo.crc = APP_INFO_FILE_FEATURES_SUPPORT;
1005 ret = UnpackFileCrcCheckSum(&fileInfo, &fileFrame);
1006 EXPECT_NE(SOFTBUS_OK, ret);
1007
1008 fileFrame.frameLength = 20;
1009 ret = UnpackFileCrcCheckSum(&fileInfo, &fileFrame);
1010 EXPECT_NE(SOFTBUS_OK, ret);
1011 }
1012 } // namespace OHOS