1 /*
2 * Copyright (c) 2022-2024 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 <fcntl.h>
17 #include <gtest/gtest.h>
18 #include <securec.h>
19 #include <sys/stat.h>
20 #include <sys/types.h>
21
22 #include "client_trans_file_listener.h"
23 #include "client_trans_proxy_file_helper.c"
24 #include "client_trans_proxy_file_manager.c"
25 #include "client_trans_proxy_manager.c"
26 #include "client_trans_session_manager.c"
27 #include "client_trans_socket_manager.c"
28 #include "session.h"
29 #include "softbus_access_token_test.h"
30 #include "softbus_app_info.h"
31 #include "softbus_def.h"
32 #include "softbus_errcode.h"
33 #include "softbus_server_frame.h"
34
35 #define TEST_FILE_LENGTH 10
36 #define TEST_FILE_CNT 2
37 #define TEST_CHANNEL_ID 2
38 #define TEST_SESSION_ID 1
39 #define TEST_SEQ 1020
40 #define TEST_SEQ_SECOND 2
41 #define TEST_HEADER_LENGTH 24
42 #define TEST_HEADER_LENGTH_MIN 13
43 #define TEST_FILE_PATH "/data/file.txt"
44 #define TEST_DATA_LENGTH 6
45 #define TEST_FILE_SIZE 1000
46 #define TEST_PATH_SIZE 50
47 #define TEST_FILE_TEST_TXT_FILE 16
48 #define TEST_FILE_MAGIC_OFFSET 0
49 #define TEST_FRAME_NUMBER 2
50 #define TEST_FRAME_DATA_LENGTH 10
51 #define TEST_FILEPATH_LENGTH 4
52 #define TEST_SEQ8 8
53 #define TEST_SEQ16 16
54 #define TEST_SEQ32 32
55 #define TEST_SEQ126 126
56 #define TEST_SEQ128 128
57 #define TEST_OS_TYPE 10
58 #define TEST_PACKET_SIZE 1024
59 #define TEST_INVALID_LEN (-1)
60
61 using namespace std;
62 using namespace testing::ext;
63
64 namespace OHOS {
65 const char *g_pkgName = "dms";
66 const char *g_sessionName = "ohos.distributedschedule.dms.test";
67 const char *g_peerNetworkId = "1234567789";
68 const char *g_groupId = "123";
69 FILE *g_fileTest = NULL;
70 FILE *g_fileSs = NULL;
71 int g_fd = 0;
72 char g_writeData[128] = "test111111111111111111111111111111111111111111111111111111111111";
73 const char *g_rootDir = "/data";
74 const char *g_destFile = "test.txt";
75 char g_recvFile[] = "/data/test.txt";
76 const char *g_sessionKey = "www.huaweitest.com";
77
78 SessionAttribute g_attr = {
79 .dataType = TYPE_MESSAGE,
80 .linkTypeNum = LINK_TYPE_WIFI_WLAN_5G,
81 };
82
83 SessionParam g_param = {
84 .sessionName = g_sessionName,
85 .peerSessionName = g_sessionName,
86 .peerDeviceId = g_peerNetworkId,
87 .groupId = g_groupId,
88 .attr = &g_attr,
89 };
90
91 const char *g_testProxyFileList[] = {
92 "/data/test.txt",
93 "/data/ss.txt",
94 };
95
96 const char *g_fileList[] = {
97 "/data/data/test.txt",
98 "/path/max/length/512/"
99 "11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
100 "11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
101 "11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
102 "11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
103 "111111111111111111111111111111111111111111111111111",
104 };
105
OnSessionOpened(int sessionId,int result)106 static int OnSessionOpened(int sessionId, int result)
107 {
108 return SOFTBUS_OK;
109 }
110
OnSessionClosed(int sessionId)111 static void OnSessionClosed(int sessionId)
112 {
113 }
114
OnBytesReceived(int sessionId,const void * data,unsigned int len)115 static void OnBytesReceived(int sessionId, const void *data, unsigned int len)
116 {
117 }
118
OnMessageReceived(int sessionId,const void * data,unsigned int len)119 static void OnMessageReceived(int sessionId, const void *data, unsigned int len)
120 {
121 }
122
123 static ISessionListener g_sessionlistener = {
124 .OnSessionOpened = OnSessionOpened,
125 .OnSessionClosed = OnSessionClosed,
126 .OnBytesReceived = OnBytesReceived,
127 .OnMessageReceived = OnMessageReceived,
128 };
129
OnSendFileProcess(int sessionId,uint64_t bytesUpload,uint64_t bytesTotal)130 static int OnSendFileProcess(int sessionId, uint64_t bytesUpload, uint64_t bytesTotal)
131 {
132 return SOFTBUS_OK;
133 }
134
OnSendFileFinished(int sessionId,const char * firstFile)135 static int OnSendFileFinished(int sessionId, const char *firstFile)
136 {
137 return SOFTBUS_OK;
138 }
139
OnFileTransError(int sessionId)140 void OnFileTransError(int sessionId)
141 {
142 return;
143 }
144
OnReceiveFileStarted(int sessionId,const char * files,int fileCnt)145 static int OnReceiveFileStarted(int sessionId, const char *files, int fileCnt)
146 {
147 return SOFTBUS_OK;
148 }
149
OnReceiveFileProcess(int sessionId,const char * firstFile,uint64_t bytesUpload,uint64_t bytesTotal)150 static int OnReceiveFileProcess(int sessionId, const char *firstFile, uint64_t bytesUpload, uint64_t bytesTotal)
151 {
152 return SOFTBUS_OK;
153 }
OnReceiveFileFinished(int sessionId,const char * files,int fileCnt)154 static void OnReceiveFileFinished(int sessionId, const char *files, int fileCnt)
155 {
156 return;
157 }
158
159 const IFileSendListener g_listener = {
160 .OnSendFileProcess = OnSendFileProcess,
161 .OnSendFileFinished = OnSendFileFinished,
162 .OnFileTransError = OnFileTransError,
163 };
164
165 const IFileReceiveListener g_fileRecvListener = {
166 .OnReceiveFileStarted = OnReceiveFileStarted,
167 .OnReceiveFileProcess = OnReceiveFileProcess,
168 .OnReceiveFileFinished = OnReceiveFileFinished,
169 .OnFileTransError = OnFileTransError,
170 };
171
172 class ClientTransProxyFileManagerTest : public testing::Test {
173 public:
ClientTransProxyFileManagerTest()174 ClientTransProxyFileManagerTest() {}
~ClientTransProxyFileManagerTest()175 ~ClientTransProxyFileManagerTest() {}
176 static void SetUpTestCase(void);
177 static void TearDownTestCase(void);
SetUp()178 void SetUp() override {}
TearDown()179 void TearDown() override {}
180 };
181
SetUpTestCase(void)182 void ClientTransProxyFileManagerTest::SetUpTestCase(void)
183 {
184 SetAceessTokenPermission("dsoftbusTransTest");
185 g_fileTest = fopen(g_testProxyFileList[0], "w+");
186 EXPECT_NE(g_fileTest, nullptr);
187
188 g_fileSs = fopen(g_testProxyFileList[1], "w+");
189 EXPECT_NE(g_fileSs, nullptr);
190 int ret = fprintf(g_fileSs, "%s", "Hello world!\n");
191 EXPECT_LT(0, ret);
192 g_fd = open(TEST_FILE_PATH, O_RDWR | O_CREAT, S_IRWXU);
193 EXPECT_NE(g_fd, -1);
194 write(g_fd, g_writeData, sizeof(g_writeData));
195 ClientTransProxyListInit();
196 }
197
TearDownTestCase(void)198 void ClientTransProxyFileManagerTest::TearDownTestCase(void)
199 {
200 int ret = fclose(g_fileTest);
201 EXPECT_EQ(ret, 0);
202 g_fileTest = NULL;
203 ret = fclose(g_fileSs);
204 EXPECT_EQ(ret, 0);
205 g_fileSs = NULL;
206 close(g_fd);
207 g_fd = -1;
208 ret = remove(g_testProxyFileList[0]);
209 EXPECT_EQ(SOFTBUS_OK, ret);
210
211 ret = remove(g_testProxyFileList[1]);
212 EXPECT_EQ(SOFTBUS_OK, ret);
213
214 ret = remove(TEST_FILE_PATH);
215 EXPECT_EQ(SOFTBUS_OK, ret);
216 ClinetTransProxyFileManagerDeinit();
217 ClientTransProxyListDeinit();
218 }
219
220 /**
221 * @tc.name: ClinetTransProxySendFileTest001
222 * @tc.desc: client trans proxy send file test, use the wrong parameter.
223 * @tc.type: FUNC
224 * @tc.require:
225 */
226 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxySendFileTest001, TestSize.Level0)
227 {
228 int32_t channelId = 1;
229 int ret = ProxyChannelSendFile(channelId, g_testProxyFileList, g_testProxyFileList, 0);
230 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
231
232 ret = ProxyChannelSendFile(channelId, nullptr, g_testProxyFileList, TEST_FILE_CNT);
233 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
234
235 const char *proxyNullFileList[] = {
236 nullptr,
237 "/path/max/length/512",
238 };
239 ret = ProxyChannelSendFile(channelId, proxyNullFileList, g_testProxyFileList, TEST_FILE_CNT);
240 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
241
242 const char *proxyZeroLileList[] = {
243 "",
244 "/path/max/length/512",
245 };
246 ret = ProxyChannelSendFile(channelId, proxyZeroLileList, g_testProxyFileList, TEST_FILE_CNT);
247 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
248
249 const char *proxyLengthFileList[] = {
250 "/path/max/length/512",
251 "/path/max/length/512/"
252 "11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
253 "11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
254 "11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
255 "11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
256 "111111111111111111111111111111111111111111111111111",
257 };
258 ret = ProxyChannelSendFile(channelId, proxyLengthFileList, g_testProxyFileList, TEST_FILE_CNT);
259 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
260
261 ret = ProxyChannelSendFile(channelId, g_testProxyFileList, nullptr, TEST_FILE_CNT);
262 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
263
264 ret = ProxyChannelSendFile(channelId, g_testProxyFileList, proxyNullFileList, TEST_FILE_CNT);
265 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
266
267 ret = ProxyChannelSendFile(channelId, g_testProxyFileList, g_testProxyFileList, TEST_FILE_CNT);
268 EXPECT_EQ(SOFTBUS_LOCK_ERR, ret);
269 }
270
271 /**
272 * @tc.name: ClinetTransRecvFileFrameDataTest001
273 * @tc.desc: clent trans recv file frame data test, use the wrong parameter.
274 * @tc.type: FUNC
275 * @tc.require:
276 */
277 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransRecvFileFrameDataTest001, TestSize.Level0)
278 {
279 int32_t channelId = 1;
280 int32_t sessionId = 1;
281 int32_t ret = ProcessRecvFileFrameData(sessionId, channelId, nullptr);
282 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
283
284 ChannelInfo *channel = static_cast<ChannelInfo *>(SoftBusCalloc(sizeof(ChannelInfo)));
285 ASSERT_TRUE(channel != nullptr);
286 channel->channelId = 1;
287 channel->isEncrypt = 0;
288 channel->linkType = LANE_BR;
289 channel->sessionKey = const_cast<char *>(g_sessionKey);
290 channel->osType = OH_TYPE;
291 ret = ClientTransProxyAddChannelInfo(ClientTransProxyCreateChannelInfo(channel));
292 EXPECT_EQ(SOFTBUS_OK, ret);
293 SoftBusFree(channel);
294 FileFrame fileFrame;
295 fileFrame.frameLength = PROXY_BR_MAX_PACKET_SIZE + 1;
296 ret = ProcessRecvFileFrameData(sessionId, channelId, &fileFrame);
297 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
298
299 fileFrame.frameType = TRANS_SESSION_FILE_FIRST_FRAME;
300 ret = ProcessRecvFileFrameData(sessionId, channelId, &fileFrame);
301 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
302 ret = ClientTransProxyDelChannelInfo(1);
303 EXPECT_EQ(SOFTBUS_OK, ret);
304 }
305
306 /**
307 * @tc.name: ClinetTransRecvFileFrameDataTest002
308 * @tc.desc: client trans recv file frame data test, use the wrong parameter.
309 * @tc.type: FUNC
310 * @tc.require:
311 */
312 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransRecvFileFrameDataTest002, TestSize.Level0)
313 {
314 int32_t channelId = 1;
315 int32_t sessionId = 1;
316
317 ChannelInfo *channel = static_cast<ChannelInfo *>(SoftBusCalloc(sizeof(ChannelInfo)));
318 ASSERT_TRUE(channel != nullptr);
319 channel->channelId = 1;
320 channel->isEncrypt = 0;
321 channel->linkType = LANE_BR;
322 channel->sessionKey = const_cast<char *>(g_sessionKey);
323 int32_t ret = ClientTransProxyAddChannelInfo(ClientTransProxyCreateChannelInfo(channel));
324 EXPECT_EQ(SOFTBUS_OK, ret);
325 SoftBusFree(channel);
326 FileFrame fileFrame;
327 fileFrame.frameLength = PROXY_BR_MAX_PACKET_SIZE - 1;
328
329 fileFrame.frameType = TRANS_SESSION_FILE_FIRST_FRAME;
330 ret = ProcessRecvFileFrameData(sessionId, channelId, &fileFrame);
331 EXPECT_EQ(SOFTBUS_NO_INIT, ret);
332
333 fileFrame.frameType = TRANS_SESSION_FILE_ONGOINE_FRAME;
334 ret = ProcessRecvFileFrameData(sessionId, channelId, &fileFrame);
335 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
336
337 fileFrame.frameType = TRANS_SESSION_FILE_ONLYONE_FRAME;
338 ret = ProcessRecvFileFrameData(sessionId, channelId, &fileFrame);
339 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
340
341 fileFrame.frameType = TRANS_SESSION_FILE_LAST_FRAME;
342 ret = ProcessRecvFileFrameData(sessionId, channelId, &fileFrame);
343 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
344
345 fileFrame.frameType = TRANS_SESSION_FILE_ACK_REQUEST_SENT;
346 ret = ProcessRecvFileFrameData(sessionId, channelId, &fileFrame);
347 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
348
349 fileFrame.frameType = TRANS_SESSION_FILE_ACK_RESPONSE_SENT;
350 ret = ProcessRecvFileFrameData(sessionId, channelId, &fileFrame);
351 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
352
353 fileFrame.frameType = TRANS_SESSION_FILE_CRC_CHECK_FRAME;
354 ret = ProcessRecvFileFrameData(sessionId, channelId, &fileFrame);
355 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
356
357 fileFrame.frameType = TRANS_SESSION_FILE_RESULT_FRAME;
358 ret = ProcessRecvFileFrameData(sessionId, channelId, &fileFrame);
359 EXPECT_EQ(SOFTBUS_TRANS_INVALID_DATA_LENGTH, ret);
360
361 fileFrame.frameType = TRANS_SESSION_FILE_ALLFILE_SENT;
362 ret = ProcessRecvFileFrameData(sessionId, channelId, &fileFrame);
363 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
364
365 fileFrame.frameType = -1;
366 ret = ProcessRecvFileFrameData(sessionId, channelId, &fileFrame);
367 EXPECT_EQ(SOFTBUS_FILE_ERR, ret);
368 ret = ClientTransProxyDelChannelInfo(1);
369 EXPECT_EQ(SOFTBUS_OK, ret);
370 }
371
372 /**
373 * @tc.name: ClinetTransProxyFileManagerInitDataTest001
374 * @tc.desc: client trans proxy file manager init data test, use the wrong or normal parameter.
375 * @tc.type: FUNC
376 * @tc.require:
377 */
378 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyFileManagerInitDataTest001, TestSize.Level0)
379 {
380 int32_t ret = ClinetTransProxyFileManagerInit();
381 EXPECT_EQ(SOFTBUS_OK, ret);
382
383 int32_t channelId = 1;
384 uint32_t seq = TEST_SEQ;
385 int32_t result = 0;
386 uint32_t side = 0;
387 ret = SendFileTransResult(channelId, seq, result, side);
388 EXPECT_EQ(SOFTBUS_TRANS_PROXY_CHANNEL_NOT_FOUND, ret);
389
390 uint32_t data = 0;
391 const uint8_t *data1 = (const uint8_t *)&data;
392 uint32_t len = TEST_HEADER_LENGTH;
393 ret = UnpackFileTransResultFrame(data1, len, nullptr, &result, &side);
394 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
395
396 ret = UnpackFileTransResultFrame(nullptr, len, &seq, &result, &side);
397 EXPECT_NE(SOFTBUS_OK, ret);
398
399 ret = UnpackFileTransResultFrame(data1, len, &seq, &result, &side);
400 EXPECT_NE(SOFTBUS_OK, ret);
401
402 data = FILE_MAGIC_NUMBER;
403 const uint8_t *data2 = (const uint8_t *)&data;
404 ret = UnpackFileTransResultFrame(data2, len, &seq, &result, &side);
405 EXPECT_NE(SOFTBUS_OK, ret);
406 }
407
408 /**
409 * @tc.name: ClinetTransProxyGetSessionFileLockTest001
410 * @tc.desc: client trans proxy get session file lock test, use the wrong or normal parameter.
411 * @tc.type: FUNC
412 * @tc.require:
413 */
414 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyGetSessionFileLockTest001, TestSize.Level0)
415 {
416 int32_t channelId = 1;
417 ProxyFileMutexLock *sessionLock = GetSessionFileLock(channelId);
418 EXPECT_NE(nullptr, sessionLock);
419
420 sessionLock = GetSessionFileLock(channelId);
421 EXPECT_NE(nullptr, sessionLock);
422
423 DelSessionFileLock(nullptr);
424 sessionLock->count = 1;
425 DelSessionFileLock(sessionLock);
426
427 sessionLock->count = 2;
428 DelSessionFileLock(sessionLock);
429 }
430
431 /**
432 * @tc.name: ClinetTransProxyCreateSendListenerInfoTest001
433 * @tc.desc: client trans proxy create send listener info test, use the wrong or normal parameter.
434 * @tc.type: FUNC
435 * @tc.require:
436 */
437 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyCreateSendListenerInfoTest001, TestSize.Level0)
438 {
439 int ret = CreateSessionServer(g_pkgName, g_sessionName, &g_sessionlistener);
440 ASSERT_EQ(SOFTBUS_OK, ret);
441
442 int32_t sessionId = 1;
443 SessionEnableStatus isEnabled = ENABLE_STATUS_INIT;
444
445 ret = ClientAddSession(&g_param, &sessionId, &isEnabled);
446 ASSERT_EQ(SOFTBUS_OK, ret);
447
448 SendListenerInfo *sendListenerInfo;
449 ret = CreateSendListenerInfo(&sendListenerInfo, TEST_CHANNEL_ID, 0);
450 EXPECT_EQ(SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND, ret);
451
452 int32_t channelId = 1;
453 int32_t osType = TEST_OS_TYPE;
454 SessionInfo sessionInfo;
455 sessionInfo.sessionId = sessionId;
456 sessionInfo.channelId = channelId;
457 sessionInfo.channelType = CHANNEL_TYPE_PROXY;
458 ret = TransClientInit();
459 ASSERT_EQ(SOFTBUS_OK, ret);
460 ret = AddSession(g_sessionName, &sessionInfo);
461 ASSERT_EQ(SOFTBUS_TRANS_SESSIONSERVER_NOT_CREATED, ret);
462
463 ret = TransSetFileSendListener(g_sessionName, &g_listener);
464 ASSERT_EQ(SOFTBUS_OK, ret);
465
466 ret = TransSetFileReceiveListener(g_sessionName, &g_fileRecvListener, g_rootDir);
467 ASSERT_EQ(SOFTBUS_OK, ret);
468
469 ret = CreateSendListenerInfo(&sendListenerInfo, channelId, 0);
470 EXPECT_EQ(SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND, ret);
471
472 ret = CreateSendListenerInfo(&sendListenerInfo, channelId, 0);
473 EXPECT_EQ(SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND, ret);
474
475 ret = AddSendListenerInfo(nullptr);
476 EXPECT_NE(SOFTBUS_OK, ret);
477
478 FileRecipientInfo *result = CreateNewRecipient(sessionId, channelId, osType);
479 EXPECT_EQ(nullptr, result);
480 }
481
482 /**
483 * @tc.name: ClinetTransProxyGetAndCheckFileSizeTest001
484 * @tc.desc: improve branch coverage, use the wrong or normal parameter.
485 * @tc.type: FUNC
486 * @tc.require:
487 */
488 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyGetAndCheckFileSizeTest001, TestSize.Level0)
489 {
490 uint64_t fileSize = 0;
491 uint64_t frameNum = 0;
492 int ret =
493 GetAndCheckFileSize(nullptr, &fileSize, &frameNum, APP_INFO_FILE_FEATURES_SUPPORT, PROXY_BLE_MAX_PACKET_SIZE);
494 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
495
496 ret = GetAndCheckFileSize(
497 g_testProxyFileList[0], &fileSize, &frameNum, APP_INFO_FILE_FEATURES_SUPPORT, PROXY_BLE_MAX_PACKET_SIZE);
498 EXPECT_EQ(SOFTBUS_OK, ret);
499
500 ret = GetAndCheckFileSize(
501 g_testProxyFileList[1], &fileSize, &frameNum, APP_INFO_FILE_FEATURES_NO_SUPPORT, PROXY_BLE_MAX_PACKET_SIZE);
502 EXPECT_EQ(SOFTBUS_OK, ret);
503 }
504
505 /**
506 * @tc.name: ClinetTransProxySendOneFrameTest001
507 * @tc.desc: client trans proxy send one frame test, use the wrong or normal parameter.
508 * @tc.type: FUNC
509 * @tc.require:
510 */
511 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxySendOneFrameTest001, TestSize.Level0)
512 {
513 SendListenerInfo info;
514 info.sessionId = TEST_SESSION_ID;
515 info.crc = APP_INFO_FILE_FEATURES_SUPPORT;
516 info.channelId = TEST_CHANNEL_ID;
517
518 FileFrame fileFrame = {
519 .frameType = TRANS_SESSION_BYTES,
520 .data = nullptr,
521 };
522 int ret = SendOneFrame(nullptr, &fileFrame);
523 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
524
525 ret = SendOneFrame(&info, &fileFrame);
526 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
527
528 info.crc = APP_INFO_FILE_FEATURES_NO_SUPPORT;
529 uint32_t dataTest = TEST_DATA_LENGTH;
530 fileFrame.data = (uint8_t *)&dataTest;
531 ret = SendOneFrame(&info, &fileFrame);
532 EXPECT_EQ(SOFTBUS_TRANS_PROXY_CHANNEL_NOT_FOUND, ret);
533
534 fileFrame.frameType = TRANS_SESSION_FILE_FIRST_FRAME;
535 ret = SendOneFrame(&info, &fileFrame);
536 EXPECT_EQ(SOFTBUS_TRANS_PROXY_CHANNEL_NOT_FOUND, ret);
537
538 ret = SendOneFrameFront(nullptr, fileFrame.frameType);
539 EXPECT_NE(SOFTBUS_OK, ret);
540
541 SendListenerInfo infoMiddle;
542 infoMiddle.sessionId = 1;
543 infoMiddle.channelId = 1;
544 infoMiddle.crc = APP_INFO_FILE_FEATURES_NO_SUPPORT;
545 ret = SendOneFrameMiddle(nullptr, TRANS_SESSION_FILE_ONGOINE_FRAME);
546 EXPECT_NE(SOFTBUS_OK, ret);
547
548 ret = SendOneFrameMiddle(&infoMiddle, TRANS_SESSION_FILE_ONGOINE_FRAME);
549 EXPECT_EQ(SOFTBUS_OK, ret);
550
551 ret = SendOneFrameFront(&infoMiddle, TRANS_SESSION_FILE_ONGOINE_FRAME);
552 EXPECT_EQ(SOFTBUS_OK, ret);
553
554 infoMiddle.crc = APP_INFO_FILE_FEATURES_SUPPORT;
555 infoMiddle.seq = 0;
556 ret = SendOneFrameMiddle(&infoMiddle, TRANS_SESSION_BYTES);
557 EXPECT_EQ(SOFTBUS_OK, ret);
558
559 ret = SendOneFrameMiddle(&infoMiddle, TRANS_SESSION_FILE_ONGOINE_FRAME);
560 EXPECT_EQ(SOFTBUS_TRANS_PROXY_CHANNEL_NOT_FOUND, ret);
561
562 ret = SendOneFrameFront(&infoMiddle, TRANS_SESSION_FILE_ONGOINE_FRAME);
563 EXPECT_EQ(SOFTBUS_OK, ret);
564
565 ret = SendOneFrameFront(&infoMiddle, TRANS_SESSION_FILE_FIRST_FRAME);
566 EXPECT_EQ(SOFTBUS_OK, ret);
567
568 infoMiddle.seq = TEST_SEQ;
569 ret = SendOneFrameMiddle(&infoMiddle, TRANS_SESSION_FILE_ONGOINE_FRAME);
570 EXPECT_EQ(SOFTBUS_OK, ret);
571 }
572
573 /**
574 * @tc.name: ClinetTransProxySendOneFrameTest002
575 * @tc.desc: client trans proxy send one frame test, use the wrong or normal parameter.
576 * @tc.type: FUNC
577 * @tc.require:
578 */
579 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxySendOneFrameTest002, TestSize.Level0)
580 {
581 SendListenerInfo *infoRear = static_cast<SendListenerInfo *>(SoftBusCalloc(sizeof(SendListenerInfo)));
582 infoRear->sessionId = 1;
583 infoRear->channelId = 1;
584 infoRear->crc = APP_INFO_FILE_FEATURES_NO_SUPPORT;
585 int ret = SendOneFrameRear(nullptr, TRANS_SESSION_BYTES);
586 EXPECT_NE(SOFTBUS_OK, ret);
587
588 ret = SendOneFrameRear(infoRear, TRANS_SESSION_BYTES);
589 EXPECT_EQ(SOFTBUS_OK, ret);
590
591 infoRear->crc = APP_INFO_FILE_FEATURES_SUPPORT;
592 ret = SendOneFrameRear(infoRear, TRANS_SESSION_FILE_ONLYONE_FRAME);
593 EXPECT_EQ(SOFTBUS_OK, ret);
594
595 infoRear->waitSeq = 0;
596 ret = SendOneFrameRear(infoRear, TRANS_SESSION_FILE_LAST_FRAME);
597 EXPECT_EQ(SOFTBUS_OK, ret);
598
599 infoRear->waitSeq = TEST_SEQ;
600 ret = SendOneFrameRear(infoRear, TRANS_SESSION_FILE_LAST_FRAME);
601 EXPECT_EQ(SOFTBUS_FILE_ERR, ret);
602
603 SoftBusFree(infoRear);
604 }
605
606 /**
607 * @tc.name: ClinetTransProxyFileRecipientInfoTest001
608 * @tc.desc: client trans proxy file recipient info test, use the wrong or normal parameter.
609 * @tc.type: FUNC
610 * @tc.require:
611 */
612 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyFileRecipientInfoTest001, TestSize.Level0)
613 {
614 FileRecipientInfo info;
615 info.recvFileInfo.fileFd = -2;
616 info.recvState = TRANS_FILE_RECV_ERR_STATE;
617 info.crc = APP_INFO_FILE_FEATURES_SUPPORT;
618 info.channelId = 1;
619 info.recvFileInfo.seq = TEST_SEQ;
620 info.fileListener.recvListener.OnFileTransError = nullptr;
621 ClearRecipientResources(&info);
622
623 info.fileListener.recvListener.OnFileTransError = OnFileTransError;
624 SetRecipientRecvState(&info, TRANS_FILE_RECV_IDLE_STATE);
625 EXPECT_EQ(info.recvFileInfo.fileFd, INVALID_FD);
626 ClearRecipientResources(&info);
627
628 info.crc = APP_INFO_FILE_FEATURES_NO_SUPPORT;
629 ClearRecipientResources(&info);
630
631 info.recvState = TRANS_FILE_RECV_IDLE_STATE;
632 SetRecipientRecvState(&info, TRANS_FILE_RECV_IDLE_STATE);
633 EXPECT_EQ(info.recvFileInfo.fileFd, INVALID_FD);
634 SetRecipientRecvState(&info, TRANS_FILE_RECV_PROCESS_STATE);
635 EXPECT_EQ(info.recvFileInfo.fileFd, INVALID_FD);
636 ClearRecipientResources(&info);
637
638 info.recvFileInfo.fileFd = INVALID_FD;
639 ClearRecipientResources(&info);
640 }
641
642 /**
643 * @tc.name: ClinetTransProxyFileAckReqAndResDataTest001
644 * @tc.desc: client trans proxy file ack req and res data test, use the wrong or normal parameter.
645 * @tc.type: FUNC
646 * @tc.require:
647 */
648 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyFileAckReqAndResDataTest001, TestSize.Level0)
649 {
650 int32_t channelId = 1;
651 uint32_t startSeq = TEST_SEQ;
652 uint32_t value = 0;
653 int ret = SendFileAckReqAndResData(channelId, startSeq, value, CHANNEL_TYPE_PROXY);
654 EXPECT_EQ(SOFTBUS_TRANS_PROXY_CHANNEL_NOT_FOUND, ret);
655
656 FileFrame frame;
657 frame.frameLength = 0;
658 frame.data = nullptr;
659 uint64_t dataTest = 0;
660 ret = UnpackAckReqAndResData(nullptr, &startSeq, &value);
661 EXPECT_NE(SOFTBUS_OK, ret);
662
663 ret = UnpackAckReqAndResData(&frame, &startSeq, &value);
664 EXPECT_NE(SOFTBUS_OK, ret);
665
666 frame.data = (uint8_t *)&dataTest;
667 ret = UnpackAckReqAndResData(&frame, &startSeq, &value);
668 EXPECT_NE(SOFTBUS_OK, ret);
669
670 frame.frameLength = TEST_HEADER_LENGTH;
671 ret = UnpackAckReqAndResData(&frame, &startSeq, &value);
672 EXPECT_NE(SOFTBUS_OK, ret);
673
674 dataTest = FILE_MAGIC_NUMBER;
675 frame.data = (uint8_t *)&dataTest;
676 ret = UnpackAckReqAndResData(&frame, &startSeq, &value);
677 EXPECT_EQ(SOFTBUS_OK, ret);
678 }
679
680 /**
681 * @tc.name: ClinetTransProxyPackFileDataTest001
682 * @tc.desc: client trans proxy pack file data test, use the wrong parameter.
683 * @tc.type: FUNC
684 * @tc.require:
685 */
686 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyPackFileDataTest001, TestSize.Level0)
687 {
688 FileFrame fileFrame = {
689 .frameType = TRANS_SESSION_BYTES,
690 .data = nullptr,
691 };
692 uint64_t readLength = TEST_FILE_LENGTH;
693 uint64_t fileOffset = 0;
694 SendListenerInfo info;
695 info.fd = g_fd;
696 info.packetSize = PROXY_BLE_MAX_PACKET_SIZE;
697 uint32_t seq = TEST_SEQ;
698 int64_t len = PackReadFileData(&fileFrame, readLength, fileOffset, &info);
699 EXPECT_TRUE(len == -1);
700
701 info.crc = APP_INFO_FILE_FEATURES_SUPPORT;
702 len = PackReadFileData(&fileFrame, readLength, fileOffset, &info);
703 EXPECT_TRUE(len == -1);
704
705 len = PackReadFileRetransData(&fileFrame, seq, readLength, fileOffset, &info);
706 EXPECT_TRUE(len == -1);
707
708 uint32_t dataTest = TEST_DATA_LENGTH;
709 fileFrame.data = (uint8_t *)&dataTest;
710 fileFrame.fileData = (uint8_t *)&dataTest;
711 info.crc = APP_INFO_FILE_FEATURES_NO_SUPPORT;
712 len = PackReadFileData(&fileFrame, readLength, fileOffset, &info);
713 EXPECT_EQ(TEST_FILE_LENGTH, len);
714
715 info.crc = APP_INFO_FILE_FEATURES_SUPPORT;
716 len = PackReadFileData(&fileFrame, readLength, fileOffset, &info);
717 EXPECT_EQ(TEST_FILE_LENGTH, len);
718
719 len = PackReadFileRetransData(&fileFrame, seq, readLength, fileOffset, &info);
720 EXPECT_EQ(SOFTBUS_TRANS_PROXY_CHANNEL_NOT_FOUND, len);
721 }
722
723 /**
724 * @tc.name: ClinetTransProxyPackFileDataFrameTest001
725 * @tc.desc: client trans proxy pack file data frame test, use normal parameter.
726 * @tc.type: FUNC
727 * @tc.require:
728 */
729 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyPackFileDataFrameTest001, TestSize.Level0)
730 {
731 uint32_t dataTest = TEST_DATA_LENGTH;
732 FileFrame fileFrame = {
733 .magic = FILE_MAGIC_NUMBER,
734 .frameType = TRANS_SESSION_BYTES,
735 .frameLength = 0,
736 .data = (uint8_t *)&dataTest,
737 .fileData = (uint8_t *)&dataTest,
738 };
739
740 FileRecipientInfo info = {
741 .crc = APP_INFO_FILE_FEATURES_NO_SUPPORT,
742 .osType = OH_TYPE,
743 };
744
745 uint32_t fileDataLen = 0;
746 int ret = UnpackFileDataFrame(&info, &fileFrame, &fileDataLen);
747 EXPECT_NE(SOFTBUS_OK, ret);
748
749 fileFrame.frameLength = TEST_HEADER_LENGTH;
750 ret = UnpackFileDataFrame(&info, &fileFrame, &fileDataLen);
751 EXPECT_EQ(SOFTBUS_OK, ret);
752
753 info.crc = APP_INFO_FILE_FEATURES_SUPPORT;
754 info.osType = OH_TYPE;
755 ret = UnpackFileDataFrame(&info, &fileFrame, &fileDataLen);
756 EXPECT_EQ(SOFTBUS_INVALID_DATA_HEAD, ret);
757
758 fileFrame.magic = 0;
759 fileFrame.frameLength = TEST_HEADER_LENGTH_MIN;
760 ret = UnpackFileDataFrame(&info, &fileFrame, &fileDataLen);
761 EXPECT_EQ(SOFTBUS_TRANS_INVALID_DATA_LENGTH, ret);
762 }
763
764 /**
765 * @tc.name: ClinetTransProxyRetransFileFrameTest001
766 * @tc.desc: client trans proxy retrans file frame test, use normal parameter.
767 * @tc.type: FUNC
768 * @tc.require:
769 */
770 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyRetransFileFrameTest001, TestSize.Level0)
771 {
772 SendListenerInfo info = {
773 .channelId = 1,
774 .fd = g_fd,
775 .fileSize = TEST_FILE_SIZE,
776 .frameNum = 1,
777 .crc = APP_INFO_FILE_FEATURES_NO_SUPPORT,
778 };
779 int ret = RetransFileFrameBySeq(nullptr, TEST_SEQ);
780 EXPECT_NE(SOFTBUS_OK, ret);
781
782 ret = RetransFileFrameBySeq(&info, TEST_SEQ);
783 EXPECT_EQ(SOFTBUS_OK, ret);
784
785 info.crc = APP_INFO_FILE_FEATURES_SUPPORT;
786 int32_t seq = TEST_SEQ_SECOND;
787 ret = RetransFileFrameBySeq(&info, seq);
788 EXPECT_NE(SOFTBUS_OK, ret);
789
790 ret = RetransFileFrameBySeq(&info, TEST_SEQ);
791 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
792 }
793
794 /**
795 * @tc.name: ClinetTransProxyAckResponseDataHandleTest001
796 * @tc.desc: client trans proxy handle response data test, use normal parameter.
797 * @tc.type: FUNC
798 * @tc.require:
799 */
800 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyAckResponseDataHandleTest001, TestSize.Level0)
801 {
802 SendListenerInfo info = {
803 .fileSize = TEST_FILE_SIZE,
804 .crc = APP_INFO_FILE_FEATURES_NO_SUPPORT,
805 };
806 uint32_t len = 0;
807 int ret = AckResponseDataHandle(&info, nullptr, len);
808 EXPECT_EQ(SOFTBUS_OK, ret);
809
810 const char *data = "test_data";
811 ret = AckResponseDataHandle(&info, data, len);
812 EXPECT_EQ(SOFTBUS_OK, ret);
813
814 len = sizeof(AckResponseData);
815 ret = AckResponseDataHandle(&info, data, len);
816 EXPECT_EQ(SOFTBUS_OK, ret);
817
818 AckResponseData ackResponseData = {
819 .startSeq = FILE_SEND_ACK_RESULT_SUCCESS,
820 .seqResult = TEST_SEQ_SECOND,
821 };
822 const char *dataTest = reinterpret_cast<const char*>(&ackResponseData);
823 ret = AckResponseDataHandle(&info, dataTest, len);
824 EXPECT_EQ(SOFTBUS_OK, ret);
825 }
826
827 /**
828 * @tc.name: ClinetTransProxyGetFullRecvPathTest001
829 * @tc.desc: client trans proxy get full recv path test, use normal parameter.
830 * @tc.type: FUNC
831 * @tc.require:
832 */
833 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyGetFullRecvPathTest001, TestSize.Level0)
834 {
835 char *result = GetFullRecvPath(nullptr, nullptr);
836 EXPECT_EQ(nullptr, result);
837 const char *filePath1 = "";
838 const char *recvRootDir1 = "";
839
840 result = GetFullRecvPath(filePath1, recvRootDir1);
841 EXPECT_NE(nullptr, result);
842
843 const char *filePath2 = "/test.txt";
844 result = GetFullRecvPath(filePath2, recvRootDir1);
845 EXPECT_NE(nullptr, result);
846
847 const char *recvRootDir2 = "/data/";
848 result = GetFullRecvPath(filePath1, recvRootDir2);
849 EXPECT_NE(nullptr, result);
850
851 result = GetFullRecvPath(filePath2, recvRootDir2);
852 EXPECT_NE(nullptr, result);
853
854 const char *filePath3 = "/test.txt";
855 const char *recvRootDir3 = "/data";
856 result = GetFullRecvPath(filePath3, recvRootDir2);
857 EXPECT_NE(nullptr, result);
858
859 result = GetFullRecvPath(filePath2, recvRootDir3);
860 EXPECT_NE(nullptr, result);
861 }
862
863 /**
864 * @tc.name: ClinetTransProxyGetDirPathTest001
865 * @tc.desc: client trans proxy get dir path test, use normal parameter.
866 * @tc.type: FUNC
867 * @tc.require:
868 */
869 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyGetDirPathTest001, TestSize.Level0)
870 {
871 int ret = GetDirPath(nullptr, nullptr, 0);
872 EXPECT_NE(SOFTBUS_OK, ret);
873
874 const char *fullPath1 = "";
875 char dirPath1[TEST_FILE_LENGTH] = {0};
876 ret = GetDirPath(fullPath1, nullptr, 0);
877 EXPECT_NE(SOFTBUS_OK, ret);
878
879 const char *fullPath2 = "/data/txt/";
880 ret = GetDirPath(fullPath2, nullptr, 0);
881 EXPECT_NE(SOFTBUS_OK, ret);
882
883 const char *fullPath3 = "/d/t.txt";
884 ret = GetDirPath(fullPath3, dirPath1, 0);
885 EXPECT_NE(SOFTBUS_OK, ret);
886
887 ret = GetDirPath(fullPath3, dirPath1, TEST_FILE_LENGTH);
888 EXPECT_EQ(SOFTBUS_OK, ret);
889 }
890
891 /**
892 * @tc.name: ClinetTransProxyGetAbsFullPathTest001
893 * @tc.desc: client trans proxy get path test, use normal parameter.
894 * @tc.type: FUNC
895 * @tc.require:
896 */
897 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyGetAbsFullPathTest001, TestSize.Level0)
898 {
899 int ret = GetAbsFullPath(nullptr, nullptr, 0);
900 EXPECT_NE(SOFTBUS_OK, ret);
901
902 char recvAbsPath[TEST_PATH_SIZE];
903 ret = GetAbsFullPath(g_testProxyFileList[0], recvAbsPath, TEST_PATH_SIZE);
904 EXPECT_EQ(SOFTBUS_OK, ret);
905
906 ret = GetAbsFullPath(g_testProxyFileList[0], recvAbsPath, TEST_FILE_LENGTH);
907 EXPECT_NE(SOFTBUS_OK, ret);
908
909 ret = CreateDirAndGetAbsPath(g_testProxyFileList[0], nullptr, TEST_PATH_SIZE);
910 EXPECT_NE(SOFTBUS_OK, ret);
911
912 ret = CreateDirAndGetAbsPath(g_testProxyFileList[0], recvAbsPath, TEST_PATH_SIZE);
913 EXPECT_EQ(SOFTBUS_OK, ret);
914
915 ret = CreateDirAndGetAbsPath(g_testProxyFileList[0], recvAbsPath, TEST_FILE_LENGTH);
916 EXPECT_NE(SOFTBUS_OK, ret);
917 }
918
919 /**
920 * @tc.name: ClinetTransProxySendListenerInfoTest001
921 * @tc.desc: client trans proxy add and del SendListenerInfo test, use normal parameter.
922 * @tc.type: FUNC
923 * @tc.require:
924 */
925 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxySendListenerInfoTest001, TestSize.Level0)
926 {
927 SendListenerInfo *info = static_cast<SendListenerInfo *>(SoftBusCalloc(sizeof(SendListenerInfo)));
928 EXPECT_TRUE(info != nullptr);
929 info->sessionId = 1;
930 info->crc = 1;
931 info->channelId = 1;
932 int32_t ret = AddSendListenerInfo(info);
933 EXPECT_EQ(SOFTBUS_OK, ret);
934
935 int32_t sessionId = 1;
936 uint32_t seq = 0;
937 int32_t res = 0;
938 ret = ProcessFileRecvResult(sessionId, seq, res);
939 EXPECT_EQ(SOFTBUS_OK, ret);
940
941 DelSendListenerInfo(nullptr);
942
943 DelSendListenerInfo(info);
944 }
945
946 /**
947 * @tc.name: ClinetTransProxyFileTransStartInfoTest001
948 * @tc.desc: client trans proxy pack file start info test, use normal parameter.
949 * @tc.type: FUNC
950 * @tc.require:
951 */
952 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyFileTransStartInfoTest001, TestSize.Level0)
953 {
954 int ret = PackFileTransStartInfo(nullptr, nullptr, TEST_FILE_TEST_TXT_FILE, nullptr);
955 EXPECT_NE(SOFTBUS_OK, ret);
956
957 uint32_t dataTest = TEST_DATA_LENGTH;
958 FileFrame fileFrame = {
959 .frameLength = 0,
960 .data = (uint8_t *)&dataTest,
961 .fileData = (uint8_t *)&dataTest,
962 };
963 SendListenerInfo info;
964 info.crc = APP_INFO_FILE_FEATURES_SUPPORT;
965 info.sessionId = 1;
966 info.channelId = 1;
967 info.packetSize = PROXY_BLE_MAX_PACKET_SIZE;
968
969 ret = PackFileTransStartInfo(&fileFrame, g_testProxyFileList[0], TEST_FILE_TEST_TXT_FILE, &info);
970 EXPECT_EQ(SOFTBUS_OK, ret);
971
972 info.crc = APP_INFO_FILE_FEATURES_NO_SUPPORT;
973 ret = PackFileTransStartInfo(&fileFrame, g_testProxyFileList[0], TEST_FILE_TEST_TXT_FILE, &info);
974 EXPECT_EQ(SOFTBUS_OK, ret);
975 }
976
977 /**
978 * @tc.name: ClinetTransProxyUnFileTransStartInfoTest001
979 * @tc.desc: client trans proxy pack file data frame test, use normal parameter.
980 * @tc.type: FUNC
981 * @tc.require:
982 */
983 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyUnFileTransStartInfoTest001, TestSize.Level0)
984 {
985 uint32_t packetSize = TEST_PACKET_SIZE;
986 int ret = UnpackFileTransStartInfo(nullptr, nullptr, nullptr, packetSize);
987 EXPECT_NE(SOFTBUS_OK, ret);
988
989 uint32_t dataTest = TEST_DATA_LENGTH;
990 FileFrame fileFrame = {
991 .frameLength = 0,
992 .data = (uint8_t *)&dataTest,
993 .fileData = (uint8_t *)&dataTest,
994 };
995 FileRecipientInfo info;
996 info.crc = APP_INFO_FILE_FEATURES_SUPPORT;
997 info.osType = OH_TYPE;
998 SingleFileInfo singleFileInfo;
999 ret = UnpackFileTransStartInfo(&fileFrame, &info, &singleFileInfo, packetSize);
1000 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1001
1002 fileFrame.frameLength = TEST_HEADER_LENGTH;
1003 ret = UnpackFileTransStartInfo(&fileFrame, &info, &singleFileInfo, packetSize);
1004 EXPECT_EQ(SOFTBUS_TRANS_INVALID_DATA_LENGTH, ret);
1005
1006 uint32_t data = FILE_MAGIC_NUMBER;
1007 fileFrame.data = (uint8_t *)&data;
1008 ret = UnpackFileTransStartInfo(&fileFrame, &info, &singleFileInfo, packetSize);
1009 EXPECT_EQ(SOFTBUS_TRANS_INVALID_DATA_LENGTH, ret);
1010
1011 info.crc = APP_INFO_FILE_FEATURES_NO_SUPPORT;
1012 fileFrame.frameLength = 0;
1013 ret = UnpackFileTransStartInfo(&fileFrame, &info, &singleFileInfo, packetSize);
1014 EXPECT_NE(SOFTBUS_OK, ret);
1015
1016 fileFrame.frameLength = FRAME_DATA_SEQ_OFFSET;
1017 ret = UnpackFileTransStartInfo(&fileFrame, &info, &singleFileInfo, packetSize);
1018 EXPECT_EQ(SOFTBUS_OK, ret);
1019
1020 fileFrame.frameLength = FRAME_DATA_SEQ_OFFSET + TEST_HEADER_LENGTH;
1021 ret = UnpackFileTransStartInfo(&fileFrame, &info, &singleFileInfo, packetSize);
1022 EXPECT_EQ(SOFTBUS_OK, ret);
1023 }
1024
1025 /**
1026 * @tc.name: ClinetTransProxyFileCrcCheckSumTest001
1027 * @tc.desc: client trans proxy crc check test, use normal parameter.
1028 * @tc.type: FUNC
1029 * @tc.require:
1030 */
1031 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyFileCrcCheckSumTest001, TestSize.Level0)
1032 {
1033 int ret = SendFileCrcCheckSum(nullptr);
1034 EXPECT_NE(SOFTBUS_OK, ret);
1035
1036 SendListenerInfo info;
1037 info.crc = APP_INFO_FILE_FEATURES_NO_SUPPORT;
1038 ret = SendFileCrcCheckSum(&info);
1039 EXPECT_EQ(SOFTBUS_OK, ret);
1040
1041 info.crc = APP_INFO_FILE_FEATURES_SUPPORT;
1042 ret = SendFileCrcCheckSum(&info);
1043 EXPECT_NE(SOFTBUS_OK, ret);
1044
1045 ret = UnpackFileCrcCheckSum(nullptr, nullptr);
1046 EXPECT_NE(SOFTBUS_OK, ret);
1047
1048 FileRecipientInfo fileInfo;
1049 fileInfo.crc = APP_INFO_FILE_FEATURES_NO_SUPPORT;
1050 FileFrame fileFrame;
1051 ret = UnpackFileCrcCheckSum(&fileInfo, &fileFrame);
1052 EXPECT_EQ(SOFTBUS_OK, ret);
1053
1054 fileInfo.crc = APP_INFO_FILE_FEATURES_SUPPORT;
1055 ret = UnpackFileCrcCheckSum(&fileInfo, &fileFrame);
1056 EXPECT_NE(SOFTBUS_OK, ret);
1057
1058 fileFrame.frameLength = 20;
1059 ret = UnpackFileCrcCheckSum(&fileInfo, &fileFrame);
1060 EXPECT_NE(SOFTBUS_OK, ret);
1061 }
1062
1063 /**
1064 * @tc.name: ClinetTransProxyFileToFrameTest001
1065 * @tc.desc: client trans proxy send file test, use the wrong or normal parameter.
1066 * @tc.type: FUNC
1067 * @tc.require:
1068 */
1069 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyFileToFrameTest001, TestSize.Level0)
1070 {
1071 SendListenerInfo info;
1072 info.sessionId = 1;
1073 info.crc = 1;
1074 info.channelId = 1;
1075
1076 int ret = SendSingleFile(&info, nullptr, g_testProxyFileList[0]);
1077 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1078
1079 ret = FileToFrameAndSendFile(nullptr, g_testProxyFileList[0], g_testProxyFileList[0]);
1080 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1081
1082 ret = FileToFrameAndSendFile(&info, g_testProxyFileList[0], nullptr);
1083 EXPECT_EQ(SOFTBUS_FILE_ERR, ret);
1084
1085 ret = FileToFrameAndSendFile(&info, nullptr, g_testProxyFileList[0]);
1086 EXPECT_EQ(SOFTBUS_FILE_ERR, ret);
1087
1088 ret = FileToFrameAndSendFile(&info, g_testProxyFileList[0], g_testProxyFileList[0]);
1089 EXPECT_EQ(SOFTBUS_FILE_ERR, ret);
1090
1091 ret = SendSingleFile(&info, g_testProxyFileList[0], g_testProxyFileList[0]);
1092 EXPECT_EQ(SOFTBUS_FILE_ERR, ret);
1093
1094 ret = SendFileList(info.channelId, g_testProxyFileList, TEST_FILE_CNT);
1095 EXPECT_EQ(SOFTBUS_TRANS_PROXY_CHANNEL_NOT_FOUND, ret);
1096
1097 ret = SendFileList(info.channelId, nullptr, TEST_FILE_CNT);
1098 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1099 }
1100
1101 /**
1102 * @tc.name: ClinetTransProxyFileToFrameTest002
1103 * @tc.desc: client trans proxy file to frame test, use normal parameter.
1104 * @tc.type: FUNC
1105 * @tc.require:
1106 */
1107 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyFileToFrameTest002, TestSize.Level0)
1108 {
1109 SendListenerInfo sendInfo = {
1110 .channelId = 1,
1111 .sessionId = 1,
1112 .crc = APP_INFO_FILE_FEATURES_NO_SUPPORT,
1113 };
1114
1115 int ret = FileToFrameAndSendFile(&sendInfo, g_testProxyFileList[0], g_destFile);
1116 EXPECT_EQ(SOFTBUS_FILE_ERR, ret);
1117
1118 ret = FileToFrame(&sendInfo, TEST_FRAME_NUMBER, g_destFile, TEST_FILE_TEST_TXT_FILE);
1119 EXPECT_EQ(SOFTBUS_FILE_ERR, ret);
1120
1121 sendInfo.crc = APP_INFO_FILE_FEATURES_SUPPORT;
1122 ret = FileToFrame(&sendInfo, TEST_FRAME_NUMBER, g_destFile, TEST_FILE_TEST_TXT_FILE);
1123 EXPECT_EQ(SOFTBUS_FILE_ERR, ret);
1124 }
1125
1126 /**
1127 * @tc.name: ClinetTransProxyStartSendFileTest001
1128 * @tc.desc: client trans proxy start send file test, use normal parameter.
1129 * @tc.type: FUNC
1130 * @tc.require:
1131 */
1132 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyStartSendFileTest001, TestSize.Level0)
1133 {
1134 SendListenerInfo sendInfo = {
1135 .channelId = 1,
1136 .sessionId = 1,
1137 .crc = APP_INFO_FILE_FEATURES_NO_SUPPORT,
1138 };
1139
1140 int ret = ProxyStartSendFile(&sendInfo, g_testProxyFileList, g_testProxyFileList, TEST_FILE_CNT);
1141 EXPECT_EQ(SOFTBUS_FILE_ERR, ret);
1142 }
1143
1144 /**
1145 * @tc.name: ClinetTransProxyCheckFileTest001
1146 * @tc.desc: client trans proxy start send file test, use normal parameter.
1147 * @tc.type: FUNC
1148 * @tc.require:
1149 */
1150 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyCheckFileTest001, TestSize.Level0)
1151 {
1152 bool result = CheckRecvFileExist(nullptr);
1153 EXPECT_EQ(false, result);
1154
1155 result = CheckRecvFileExist(g_testProxyFileList[0]);
1156 EXPECT_EQ(false, result);
1157 }
1158
1159 /**
1160 * @tc.name: ClinetTransProxyPutToRcvListTest001
1161 * @tc.desc: client trans proxy put to file list test, use normal parameter.
1162 * @tc.type: FUNC
1163 * @tc.require:
1164 */
1165 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyPutToRcvListTest001, TestSize.Level0)
1166 {
1167 int ret = PutToRecvFileList(nullptr, nullptr);
1168 EXPECT_NE(SOFTBUS_OK, ret);
1169
1170 FileRecipientInfo recipient = {
1171 .recvFileInfo.fileStatus = NODE_ERR,
1172 };
1173 const SingleFileInfo file = {0};
1174 ret = PutToRecvFileList(&recipient, &file);
1175 EXPECT_NE(SOFTBUS_OK, ret);
1176
1177 recipient.recvFileInfo.fileStatus = NODE_IDLE;
1178 ret = PutToRecvFileList(&recipient, &file);
1179 EXPECT_NE(SOFTBUS_OK, ret);
1180
1181 SingleFileInfo trueFile = {0};
1182 (void)memcpy_s(trueFile.filePath, MAX_FILE_PATH_NAME_LEN, g_recvFile, sizeof(g_recvFile));
1183 ret = PutToRecvFileList(&recipient, &trueFile);
1184 EXPECT_EQ(SOFTBUS_OK, ret);
1185 }
1186
1187 /**
1188 * @tc.name: ClinetTransProxyRecvRecipientInfoListTest001
1189 * @tc.desc: client trans proxy recv recipient info test, use normal parameter.
1190 * @tc.type: FUNC
1191 * @tc.require:
1192 */
1193 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyRecvRecipientInfoListTest001, TestSize.Level0)
1194 {
1195 int32_t sessionId = 1;
1196 FileRecipientInfo *result = GetRecipientNoLock(sessionId);
1197 EXPECT_EQ(nullptr, result);
1198
1199 uint32_t seq = 0;
1200 int32_t res = 0;
1201 int ret = ProcessFileSendResult(sessionId, seq, res);
1202 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
1203
1204 sessionId = -1;
1205 result = GetRecipientNoLock(sessionId);
1206 EXPECT_EQ(nullptr, result);
1207
1208 ret = ProcessFileSendResult(sessionId, seq, res);
1209 EXPECT_NE(SOFTBUS_OK, ret);
1210
1211 ret = ProcessFileRecvResult(sessionId, seq, res);
1212 EXPECT_NE(SOFTBUS_OK, ret);
1213
1214 ReleaseRecipientRef(nullptr);
1215
1216 FileRecipientInfo *info = static_cast<FileRecipientInfo *>(SoftBusCalloc(sizeof(FileRecipientInfo)));
1217 info->objRefCount = 2,
1218 ReleaseRecipientRef(info);
1219
1220 info->objRefCount = 1;
1221 ReleaseRecipientRef(info);
1222 }
1223
1224 /**
1225 * @tc.name: ClinetTransProxyGetRecipientInfoListTest001
1226 * @tc.desc: client trans proxy get recipient info test, use normal parameter.
1227 * @tc.type: FUNC
1228 * @tc.require:
1229 */
1230 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyGetRecipientInfoListTest001, TestSize.Level0)
1231 {
1232 int32_t sessionId = -1;
1233 int32_t channelId = 1;
1234 int32_t osType = TEST_OS_TYPE;
1235 FileRecipientInfo *result = GetRecipientInProcessRef(sessionId);
1236 EXPECT_EQ(nullptr, result);
1237
1238 result = GetRecipientInCreateFileRef(sessionId, channelId, osType);
1239 EXPECT_EQ(nullptr, result);
1240
1241 sessionId = 1;
1242 result = GetRecipientInCreateFileRef(sessionId, channelId, osType);
1243 EXPECT_EQ(nullptr, result);
1244
1245 result = GetRecipientInProcessRef(sessionId);
1246 EXPECT_EQ(nullptr, result);
1247 }
1248
1249 /**
1250 * @tc.name: ClinetTransProxyWriteEmptyFrameTest001
1251 * @tc.desc: client trans proxy write empty frame test, use normal parameter.
1252 * @tc.type: FUNC
1253 * @tc.require:
1254 */
1255 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyWriteEmptyFrameTest001, TestSize.Level0)
1256 {
1257 int32_t cnt = 0;
1258 int ret = WriteEmptyFrame(nullptr, cnt);
1259 EXPECT_NE(SOFTBUS_OK, ret);
1260
1261 SingleFileInfo info = {0};
1262 ret = WriteEmptyFrame(&info, cnt);
1263 EXPECT_EQ(SOFTBUS_OK, ret);
1264
1265 cnt = 1;
1266 ret = WriteEmptyFrame(&info, cnt);
1267 EXPECT_NE(SOFTBUS_OK, ret);
1268
1269 info.fileFd = g_fd;
1270 info.oneFrameLen = -1;
1271 info.fileOffset = 0;
1272 ret = WriteEmptyFrame(&info, cnt);
1273 EXPECT_NE(SOFTBUS_OK, ret);
1274
1275 info.oneFrameLen = TEST_FILE_LENGTH;
1276 ret = WriteEmptyFrame(&info, cnt);
1277 EXPECT_EQ(SOFTBUS_OK, ret);
1278 }
1279
1280 /**
1281 * @tc.name: ClinetTransProxyProcessOneFrameCRCTest001
1282 * @tc.desc: client trans proxy process one frameCRC test, use normal parameter.
1283 * @tc.type: FUNC
1284 * @tc.require:
1285 */
1286 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyProcessOneFrameCRCTest001, TestSize.Level0)
1287 {
1288 uint32_t dataLen = 0;
1289 int32_t ret = ProcessOneFrameCRC(nullptr, dataLen, nullptr);
1290 EXPECT_NE(SOFTBUS_OK, ret);
1291
1292 uint8_t *emptyBuff = static_cast<uint8_t *>(SoftBusCalloc(TEST_FILE_SIZE));
1293 if (emptyBuff == NULL) {
1294 return;
1295 }
1296 FileFrame frame = {
1297 .frameType = TRANS_SESSION_FILE_FIRST_FRAME,
1298 .seq = TEST_SEQ32,
1299 .fileData = emptyBuff,
1300 };
1301 SingleFileInfo fileInfo = {
1302 .seq = 0,
1303 .fileFd = g_fd,
1304 .fileOffset = 0,
1305 .oneFrameLen = TEST_FILE_LENGTH,
1306 .startSeq = 0,
1307 .preStartSeq = 0,
1308 };
1309 ret = ProcessOneFrameCRC(&frame, dataLen, &fileInfo);
1310 EXPECT_NE(SOFTBUS_OK, ret);
1311
1312 frame.seq = TEST_SEQ128;
1313 fileInfo.seq = TEST_SEQ126;
1314 ret = ProcessOneFrameCRC(&frame, dataLen, &fileInfo);
1315 EXPECT_NE(SOFTBUS_OK, ret);
1316
1317 fileInfo.preStartSeq = TEST_SEQ128;
1318 ret = ProcessOneFrameCRC(&frame, dataLen, &fileInfo);
1319 EXPECT_NE(SOFTBUS_OK, ret);
1320
1321 frame.frameType = TRANS_SESSION_FILE_LAST_FRAME;
1322 ret = ProcessOneFrameCRC(&frame, dataLen, &fileInfo);
1323 EXPECT_NE(SOFTBUS_OK, ret);
1324
1325 fileInfo.startSeq = TEST_SEQ8;
1326 frame.seq = TEST_SEQ_SECOND;
1327 ret = ProcessOneFrameCRC(&frame, dataLen, &fileInfo);
1328 EXPECT_NE(SOFTBUS_OK, ret);
1329
1330 dataLen = TEST_SEQ16;
1331 ret = ProcessOneFrameCRC(&frame, dataLen, &fileInfo);
1332 EXPECT_EQ(SOFTBUS_OK, ret);
1333 SoftBusFree(emptyBuff);
1334 }
1335
1336 /**
1337 * @tc.name: ClinetTransProxyProcessOneFrameTest001
1338 * @tc.desc: client trans proxy process one frame test, use normal parameter.
1339 * @tc.type: FUNC
1340 * @tc.require:
1341 */
1342 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyProcessOneFrameTest001, TestSize.Level0)
1343 {
1344 FileFrame frame = {
1345 .frameType = TRANS_SESSION_FILE_FIRST_FRAME,
1346 .seq = TEST_SEQ32,
1347 };
1348 uint32_t dataLen = TEST_SEQ16;
1349 int32_t crc = APP_INFO_FILE_FEATURES_SUPPORT;
1350 int32_t osType = TEST_OS_TYPE;
1351 SingleFileInfo fileInfo = {
1352 .seq = 0,
1353 .fileFd = g_fd,
1354 .fileStatus = NODE_ERR,
1355 .fileOffset = 0,
1356 .oneFrameLen = TEST_FILE_LENGTH,
1357 .startSeq = 0,
1358 .preStartSeq = 0,
1359 };
1360 int ret = ProcessOneFrame(&frame, dataLen, crc, &fileInfo, osType);
1361 EXPECT_NE(SOFTBUS_OK, ret);
1362
1363 fileInfo.fileStatus = NODE_IDLE;
1364 ret = ProcessOneFrame(&frame, dataLen, crc, &fileInfo, osType);
1365 EXPECT_NE(SOFTBUS_OK, ret);
1366
1367 crc = APP_INFO_FILE_FEATURES_NO_SUPPORT;
1368 ret = ProcessOneFrame(&frame, dataLen, crc, &fileInfo, osType);
1369 EXPECT_NE(SOFTBUS_OK, ret);
1370 }
1371
1372 /**
1373 * @tc.name: ClinetTransProxyCrcCheckTest001
1374 * @tc.desc: client trans proxy process crc check test, use normal parameter.
1375 * @tc.type: FUNC
1376 * @tc.require:
1377 */
1378 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyCrcCheckTest001, TestSize.Level0)
1379 {
1380 FileFrame frame = {
1381 .seq = TEST_SEQ32,
1382 .crc = APP_INFO_FILE_FEATURES_SUPPORT,
1383 };
1384 int32_t sessionId = -1;
1385
1386 int ret = ProcessCrcCheckSumData(sessionId, nullptr);
1387 EXPECT_NE(SOFTBUS_OK, ret);
1388
1389 ret = ProcessCrcCheckSumData(sessionId, &frame);
1390 EXPECT_NE(SOFTBUS_OK, ret);
1391
1392 sessionId = 1;
1393 ret = ProcessCrcCheckSumData(sessionId, &frame);
1394 EXPECT_NE(SOFTBUS_OK, ret);
1395
1396 frame.crc = APP_INFO_FILE_FEATURES_NO_SUPPORT;
1397 ret = ProcessCrcCheckSumData(sessionId, &frame);
1398 EXPECT_NE(SOFTBUS_OK, ret);
1399 }
1400
1401 /**
1402 * @tc.name: ClinetTransProxyFileAckRequestTest001
1403 * @tc.desc: client trans proxy file ack request test, use normal parameter.
1404 * @tc.type: FUNC
1405 * @tc.require:
1406 */
1407 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyFileAckRequestTest001, TestSize.Level0)
1408 {
1409 FileFrame frame = {
1410 .frameLength = TEST_HEADER_LENGTH,
1411 .crc = APP_INFO_FILE_FEATURES_SUPPORT,
1412 .data = nullptr,
1413 };
1414 int32_t sessionId = -1;
1415
1416 int ret = ProcessFileAckRequest(sessionId, nullptr);
1417 EXPECT_NE(SOFTBUS_OK, ret);
1418
1419 ret = ProcessFileAckRequest(sessionId, &frame);
1420 EXPECT_NE(SOFTBUS_OK, ret);
1421
1422 sessionId = 1;
1423 uint32_t dataTest = 0;
1424 dataTest = FILE_MAGIC_NUMBER;
1425 frame.data = (uint8_t *)&dataTest;
1426 ret = ProcessFileAckRequest(sessionId, &frame);
1427 EXPECT_NE(SOFTBUS_OK, ret);
1428
1429 ret = ProcessFileAckRequest(sessionId, &frame);
1430 EXPECT_NE(SOFTBUS_OK, ret);
1431 }
1432
1433 /**
1434 * @tc.name: ClinetTransProxyFileAckResponseTest001
1435 * @tc.desc: client trans proxy file ack response test, use normal parameter.
1436 * @tc.type: FUNC
1437 * @tc.require:
1438 */
1439 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyFileAckResponseTest001, TestSize.Level0)
1440 {
1441 FileFrame frame = {
1442 .frameLength = 0,
1443 .crc = APP_INFO_FILE_FEATURES_SUPPORT,
1444 .data = nullptr,
1445 };
1446 int32_t sessionId = -1;
1447
1448 int ret = ProcessFileAckResponse(sessionId, nullptr);
1449 EXPECT_NE(SOFTBUS_OK, ret);
1450
1451 ret = ProcessFileAckResponse(sessionId, &frame);
1452 EXPECT_NE(SOFTBUS_OK, ret);
1453
1454 uint32_t dataTest[TEST_FRAME_DATA_LENGTH] = {0};
1455 dataTest[TEST_FILE_MAGIC_OFFSET] = FILE_MAGIC_NUMBER;
1456 frame.data = (uint8_t *)dataTest;
1457 ret = ProcessFileAckResponse(sessionId, &frame);
1458 EXPECT_NE(SOFTBUS_OK, ret);
1459
1460 SendListenerInfo info;
1461 info.sessionId = 1;
1462 info.crc = 1;
1463 info.channelId = 1;
1464 ret = AddSendListenerInfo(&info);
1465 EXPECT_EQ(SOFTBUS_OK, ret);
1466
1467 frame.frameLength = TEST_HEADER_LENGTH;
1468 *(uint64_t *)(frame.data + FRAME_MAGIC_OFFSET) = FRAME_DATA_SEQ_OFFSET + FRAME_DATA_SEQ_OFFSET;
1469 ret = ProcessFileAckResponse(sessionId, &frame);
1470 EXPECT_NE(SOFTBUS_OK, ret);
1471
1472 sessionId = 1;
1473 ret = ProcessFileAckResponse(sessionId, &frame);
1474 EXPECT_EQ(SOFTBUS_OK, ret);
1475 }
1476
1477 /**
1478 * @tc.name: ClinetTransProxyCheckParameterTest001
1479 * @tc.desc: client trans proxy check parameter test, use normal parameter.
1480 * @tc.type: FUNC
1481 * @tc.require:
1482 */
1483 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyCheckParameterTest001, TestSize.Level0)
1484 {
1485 bool result = IsValidFileString(nullptr, TEST_FILE_CNT, TEST_FILE_LENGTH);
1486 EXPECT_EQ(false, result);
1487
1488 uint32_t fileNum = 0;
1489 result = IsValidFileString(g_testProxyFileList, fileNum, TEST_FILE_LENGTH);
1490 EXPECT_EQ(false, result);
1491
1492 int32_t sessionId = 1;
1493 int ret = ProcessFileTransResult(sessionId, nullptr);
1494 EXPECT_NE(SOFTBUS_OK, ret);
1495 }
1496
1497 /**
1498 * @tc.name: ClinetTransProxyProcessFileListDataTest001
1499 * @tc.desc: client trans proxy process file list data test, use normal parameter.
1500 * @tc.type: FUNC
1501 * @tc.require:
1502 */
1503 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyProcessFileListDataTest001, TestSize.Level0)
1504 {
1505 int32_t sessionId = 1;
1506 FileFrame frame = {
1507 .frameLength = TEST_FILE_SIZE,
1508 .data = (uint8_t *)"00010010datatest,"
1509 };
1510 int ret = ProcessFileListData(sessionId, &frame);
1511 EXPECT_NE(SOFTBUS_OK, ret);
1512 }
1513
1514 /**
1515 * @tc.name: ClinetTransProxyGetFileInfoTest001
1516 * @tc.desc: client trans proxy get file info test, use normal parameter.
1517 * @tc.type: FUNC
1518 * @tc.require:
1519 */
1520 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyGetFileInfoTest001, TestSize.Level0)
1521 {
1522 FileFrame frame = {
1523 .frameLength = 0,
1524 .data = (uint8_t *)"00010010datatest.txt",
1525 };
1526 FileRecipientInfo info = {
1527 .fileListener.rootDir = "../test",
1528 };
1529 info.crc = APP_INFO_FILE_FEATURES_SUPPORT;
1530 SingleFileInfo file;
1531 uint32_t packetSize = TEST_PACKET_SIZE;
1532 int ret = GetFileInfoByStartFrame(nullptr, nullptr, nullptr, packetSize);
1533 EXPECT_NE(SOFTBUS_OK, ret);
1534
1535 ret = GetFileInfoByStartFrame(&frame, &info, &file, packetSize);
1536 EXPECT_NE(SOFTBUS_OK, ret);
1537
1538 ret = memcpy_s(info.fileListener.rootDir, TEST_FILEPATH_LENGTH, g_rootDir + 1, TEST_FILEPATH_LENGTH);
1539 ASSERT_EQ(SOFTBUS_OK, ret);
1540 ret = GetFileInfoByStartFrame(&frame, &info, &file, packetSize);
1541 EXPECT_NE(SOFTBUS_OK, ret);
1542
1543 frame.frameLength = FRAME_DATA_SEQ_OFFSET + 9;
1544 info.crc = APP_INFO_FILE_FEATURES_NO_SUPPORT;
1545 ret = GetFileInfoByStartFrame(&frame, &info, &file, packetSize);
1546 EXPECT_EQ(SOFTBUS_OK, ret);
1547 }
1548
1549 /**
1550 * @tc.name: ClinetTransProxyWriteFrameTest001
1551 * @tc.desc: client trans proxy write frame to file test, use normal parameter.
1552 * @tc.type: FUNC
1553 * @tc.require:
1554 */
1555 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyWriteFrameTest001, TestSize.Level0)
1556 {
1557 int32_t sessionId = 1;
1558 FileFrame frame = {
1559 .frameLength = 0,
1560 .data = (uint8_t *)"00010010datatest.txt",
1561 };
1562 int ret = WriteFrameToFile(sessionId, &frame);
1563 EXPECT_NE(SOFTBUS_OK, ret);
1564
1565 frame.frameLength = TEST_DATA_LENGTH;
1566 ret = WriteFrameToFile(sessionId, &frame);
1567 EXPECT_NE(SOFTBUS_OK, ret);
1568 }
1569
1570 /**
1571 * @tc.name: ClinetTransProxyChannelSendFileStreamTest001
1572 * @tc.desc: client trans proxy write frame to file test, use normal parameter.
1573 * @tc.type: FUNC
1574 * @tc.require:
1575 */
1576 HWTEST_F(ClientTransProxyFileManagerTest, ProxyChannelSendFileStreamTest001, TestSize.Level0)
1577 {
1578 int32_t channelId = 1;
1579 const char *data = "test_data";
1580 uint32_t len = TEST_HEADER_LENGTH;
1581 int32_t type = 1;
1582
1583 int ret = ProxyChannelSendFileStream(channelId, data, len, type);
1584 EXPECT_EQ(SOFTBUS_TRANS_PROXY_CHANNEL_NOT_FOUND, ret);
1585 }
1586
1587 /**
1588 * @tc.name: ClinetTransProxySendFileTransResult001
1589 * @tc.desc: client trans proxy write frame to file test, use normal parameter.
1590 * @tc.type: FUNC
1591 * @tc.require:
1592 */
1593 HWTEST_F(ClientTransProxyFileManagerTest, ProxySendFileTransResultTest001, TestSize.Level0)
1594 {
1595 int32_t channelId = 1;
1596 uint32_t seq = TEST_SEQ;
1597 int32_t result = 0;
1598 uint32_t side = 0;
1599
1600 int ret = SendFileTransResult(channelId, seq, result, side);
1601 EXPECT_NE(SOFTBUS_MALLOC_ERR, ret);
1602 }
1603
1604 /**
1605 * @tc.name: ClinetUnpackFileTransResultFrame001
1606 * @tc.desc: client trans proxy write frame to file test, use normal parameter.
1607 * @tc.type: FUNC
1608 * @tc.require:
1609 */
1610 HWTEST_F(ClientTransProxyFileManagerTest, ProxyUnpackFileTransResultFrame001, TestSize.Level0)
1611 {
1612 uint32_t seq = TEST_SEQ;
1613 int32_t result = 0;
1614 uint32_t side = 0;
1615 uint32_t data = 0;
1616 const uint8_t *data1 = (const uint8_t *)&data;
1617 uint32_t len = TEST_HEADER_LENGTH;
1618
1619 int ret = UnpackFileTransResultFrame(data1, len, nullptr, &result, &side);
1620 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1621
1622 ret = UnpackFileTransResultFrame(data1, len, &seq, nullptr, &side);
1623 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1624
1625 ret = UnpackFileTransResultFrame(data1, len, &seq, &result, nullptr);
1626 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1627
1628 ret = UnpackFileTransResultFrame(nullptr, len, &seq, &result, &side);
1629 EXPECT_EQ(SOFTBUS_TRANS_INVALID_DATA_LENGTH, ret);
1630
1631 ret = UnpackFileTransResultFrame(data1, len, &seq, &result, &side);
1632 EXPECT_NE(SOFTBUS_OK, ret);
1633
1634 len = 0;
1635 ret = UnpackFileTransResultFrame(data1, len, &seq, &result, &side);
1636 EXPECT_EQ(SOFTBUS_TRANS_INVALID_DATA_LENGTH, ret);
1637 }
1638
1639 /**
1640 * @tc.name: ClinetTransProxyFileAckReqAndResDataTest002
1641 * @tc.desc: client trans proxy file ack req and res data test, use the wrong or normal parameter.
1642 * @tc.type: FUNC
1643 * @tc.require:
1644 */
1645 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyFileAckReqAndResDataTest002, TestSize.Level0)
1646 {
1647 int32_t channelId = 1;
1648 uint32_t startSeq = TEST_SEQ;
1649 uint32_t value = 0;
1650 int ret = SendFileAckReqAndResData(channelId, startSeq, value, CHANNEL_TYPE_PROXY);
1651 EXPECT_EQ(SOFTBUS_TRANS_PROXY_CHANNEL_NOT_FOUND, ret);
1652
1653 FileFrame frame;
1654 frame.frameLength = 0;
1655 frame.data = nullptr;
1656 uint64_t dataTest = 0;
1657 ret = UnpackAckReqAndResData(nullptr, &startSeq, &value);
1658 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1659
1660 ret = UnpackAckReqAndResData(&frame, &startSeq, &value);
1661 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1662
1663 ret = UnpackAckReqAndResData(&frame, nullptr, &value);
1664 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1665
1666 ret = UnpackAckReqAndResData(&frame, &startSeq, nullptr);
1667 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1668
1669 frame.data = (uint8_t *)&dataTest;
1670 ret = UnpackAckReqAndResData(&frame, &startSeq, &value);
1671 EXPECT_EQ(SOFTBUS_TRANS_INVALID_DATA_LENGTH, ret);
1672
1673 frame.frameLength = TEST_HEADER_LENGTH;
1674 ret = UnpackAckReqAndResData(&frame, &startSeq, &value);
1675 EXPECT_EQ(SOFTBUS_INVALID_DATA_HEAD, ret);
1676
1677 dataTest = TEST_HEADER_LENGTH;
1678 frame.data = (uint8_t *)&dataTest;
1679 ret = UnpackAckReqAndResData(&frame, &startSeq, &value);
1680 EXPECT_EQ(SOFTBUS_INVALID_DATA_HEAD, ret);
1681
1682 dataTest = FILE_MAGIC_NUMBER;
1683 frame.data = (uint8_t *)&dataTest;
1684 ret = UnpackAckReqAndResData(&frame, &startSeq, &value);
1685 EXPECT_EQ(SOFTBUS_OK, ret);
1686
1687 ret = UnpackAckReqAndResData(&frame, &startSeq, &value);
1688 EXPECT_EQ(SOFTBUS_OK, ret);
1689 }
1690
1691 /**
1692 * @tc.name: ClinetTransProxyPackFileDataTest002
1693 * @tc.desc: client trans proxy pack file data test, use the wrong parameter.
1694 * @tc.type: FUNC
1695 * @tc.require:
1696 */
1697 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyPackFileDataTest002, TestSize.Level0)
1698 {
1699 FileFrame fileFrame = {
1700 .frameType = TRANS_SESSION_BYTES,
1701 .data = nullptr,
1702 };
1703 uint64_t readLength = TEST_FILE_LENGTH;
1704 uint64_t fileOffset = 0;
1705 SendListenerInfo info;
1706 info.fd = g_fd;
1707 info.packetSize = PROXY_BLE_MAX_PACKET_SIZE;
1708 uint32_t seq = TEST_SEQ;
1709 int64_t len = PackReadFileData(&fileFrame, readLength, fileOffset, &info);
1710 EXPECT_EQ(TEST_INVALID_LEN, len);
1711
1712 info.crc = APP_INFO_FILE_FEATURES_SUPPORT;
1713 len = PackReadFileData(&fileFrame, readLength, fileOffset, &info);
1714 EXPECT_EQ(TEST_INVALID_LEN, len);
1715
1716 len = PackReadFileRetransData(&fileFrame, seq, readLength, fileOffset, &info);
1717 EXPECT_EQ(TEST_INVALID_LEN, len);
1718
1719 uint32_t dataTest = TEST_DATA_LENGTH;
1720 fileFrame.data = (uint8_t *)&dataTest;
1721 fileFrame.fileData = (uint8_t *)&dataTest;
1722 info.crc = APP_INFO_FILE_FEATURES_NO_SUPPORT;
1723 len = PackReadFileData(&fileFrame, readLength, fileOffset, &info);
1724 EXPECT_EQ(TEST_FILE_LENGTH, len);
1725
1726 info.crc = APP_INFO_FILE_FEATURES_SUPPORT;
1727 len = PackReadFileData(&fileFrame, readLength, fileOffset, &info);
1728 EXPECT_EQ(TEST_FILE_LENGTH, len);
1729
1730 len = PackReadFileRetransData(&fileFrame, seq, readLength, fileOffset, &info);
1731 EXPECT_EQ(SOFTBUS_TRANS_PROXY_CHANNEL_NOT_FOUND, len);
1732 }
1733
1734 /**
1735 * @tc.name: ClinetTransProxyRetransFileFrameTest002
1736 * @tc.desc: client trans proxy retrans file frame test, use normal parameter.
1737 * @tc.type: FUNC
1738 * @tc.require:
1739 */
1740 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyRetransFileFrameTest002, TestSize.Level0)
1741 {
1742 SendListenerInfo info = {
1743 .fileSize = TEST_FILE_SIZE,
1744 .crc = APP_INFO_FILE_FEATURES_NO_SUPPORT,
1745 };
1746 int32_t seq = 0;
1747
1748 int ret = RetransFileFrameBySeq(nullptr, TEST_SEQ);
1749 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1750
1751 ret = RetransFileFrameBySeq(&info, seq);
1752 EXPECT_EQ(SOFTBUS_OK, ret);
1753
1754 ret = RetransFileFrameBySeq(&info, TEST_SEQ);
1755 EXPECT_EQ(SOFTBUS_OK, ret);
1756
1757 info.crc = APP_INFO_FILE_FEATURES_SUPPORT;
1758 seq = TEST_SEQ_SECOND;
1759
1760 ret = RetransFileFrameBySeq(&info, TEST_SEQ);
1761 EXPECT_NE(SOFTBUS_MALLOC_ERR, ret);
1762
1763 ret = RetransFileFrameBySeq(&info, TEST_SEQ);
1764 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1765
1766 ret = RetransFileFrameBySeq(&info, TEST_SEQ);
1767 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1768
1769 info.fileSize = 0;
1770 ret = RetransFileFrameBySeq(&info, seq);
1771 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1772 }
1773
1774 /**
1775 * @tc.name: ClinetTransProxyClearSendInfoTest001
1776 * @tc.desc: client trans proxy clear send info test, use normal parameter.
1777 * @tc.type: FUNC
1778 * @tc.require:
1779 */
1780 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyClearSendInfoTest001, TestSize.Level0)
1781 {
1782 SendListenerInfo info = {
1783 .fileSize = TEST_FILE_SIZE,
1784 .crc = APP_INFO_FILE_FEATURES_NO_SUPPORT,
1785 };
1786
1787 EXPECT_NO_THROW(ClearSendInfo(&info));
1788 }
1789
1790 /**
1791 * @tc.name: ClinetTransProxyCalcAllFilesInfoTest001
1792 * @tc.desc: client trans proxy calc all files info test, use normal parameter.
1793 * @tc.type: FUNC
1794 * @tc.require:
1795 */
1796 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyGetFileSizeTest001, TestSize.Level0)
1797 {
1798 const char *fileList[] = {
1799 "test0",
1800 "test1",
1801 "test2",
1802 "test3",
1803 "test4"
1804 };
1805 FilesInfo totalInfo = {
1806 .files = fileList,
1807 .fileCnt = TEST_FILE_CNT,
1808 .bytesProcessed = 0,
1809 };
1810 uint32_t fileCnt = TEST_FILE_CNT;
1811
1812 int ret = CalcAllFilesInfo(&totalInfo, fileList, fileCnt);
1813 EXPECT_EQ(SOFTBUS_FILE_ERR, ret);
1814 }
1815
1816 /**
1817 * @tc.name: ClinetTransProxyUpdateFileReceivePathTest001
1818 * @tc.desc: client trans proxy update file receive path test, use normal and error parameter.
1819 * @tc.type: FUNC
1820 * @tc.require:
1821 */
1822 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyUpdateFileReceivePathTest001, TestSize.Level0)
1823 {
1824 int32_t sessionId = TEST_SESSION_ID;
1825 FileListener *fileListener = static_cast<FileListener *>(SoftBusCalloc(sizeof(FileListener)));
1826
1827 fileListener->socketRecvCallback = NULL;
1828 int ret = UpdateFileReceivePath(sessionId, fileListener);
1829 EXPECT_EQ(SOFTBUS_OK, ret);
1830
1831 ret = UpdateFileReceivePath(sessionId, fileListener);
1832 EXPECT_EQ(SOFTBUS_OK, ret);
1833 SoftBusFree(fileListener);
1834
1835 GetRecipientInfo(sessionId);
1836 }
1837
1838 /**
1839 * @tc.name: ClinetTransProxyCreateFileFromFrameTest001
1840 * @tc.desc: client trans proxy create file from frame test, use normal and error parameter.
1841 * @tc.type: FUNC
1842 * @tc.require:
1843 */
1844 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyCreateFileFromFrameTest001, TestSize.Level0)
1845 {
1846 int32_t sessionId = TEST_SESSION_ID;
1847 int32_t channelId = TEST_CHANNEL_ID;
1848 int32_t osType = TEST_OS_TYPE;
1849 uint8_t data = 0;
1850 uint32_t packetSize = TEST_PACKET_SIZE;
1851 FileFrame fileFrame = {
1852 .frameType = TRANS_SESSION_BYTES,
1853 .data = &data,
1854 .fileData = &data,
1855 };
1856
1857 int ret = CreateFileFromFrame(sessionId, channelId, &fileFrame, osType, packetSize);
1858 EXPECT_EQ(SOFTBUS_NO_INIT, ret);
1859
1860 const char *dataFile = "TEST_FILE_DATA";
1861 uint32_t len = TEST_HEADER_LENGTH;
1862 int32_t type = 0;
1863 ProcessFileFrameData(sessionId, channelId, dataFile, len, type);
1864 }
1865
1866 /**
1867 * @tc.name: ClinetTransProxyChannelSendFileTest001
1868 * @tc.desc: client trans proxy channel send file test, use normal and error parameter.
1869 * @tc.type: FUNC
1870 * @tc.require:
1871 */
1872 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyChannelSendFileTest001, TestSize.Level0)
1873 {
1874 int32_t channelId = TEST_CHANNEL_ID;
1875 const char *sFileList[] = {
1876 "test0",
1877 "test1",
1878 "test2",
1879 "test3",
1880 "test4"
1881 };
1882 const char *dFileList[] = {
1883 "test0",
1884 "test1",
1885 "test2",
1886 "test3",
1887 "test4"
1888 };
1889 uint32_t fileCnt = TEST_FILE_CNT;
1890
1891 GenerateRemoteFiles(sFileList, fileCnt);
1892
1893 int ret = TransProxyChannelSendFile(channelId, nullptr, dFileList, fileCnt);
1894 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1895
1896 fileCnt = 0;
1897 ret = TransProxyChannelSendFile(channelId, sFileList, dFileList, fileCnt);
1898 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1899
1900 fileCnt = 12; // 为满足if条件语句大于10，所以赋值12
1901 ret = TransProxyChannelSendFile(channelId, sFileList, dFileList, fileCnt);
1902 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1903 }
1904
1905 /**
1906 * @tc.name: CheckFrameLengthTest
1907 * @tc.desc: client trans proxy channel send file test, use normal and error parameter.
1908 * @tc.type: FUNC
1909 * @tc.require:
1910 */
1911 HWTEST_F(ClientTransProxyFileManagerTest, CheckFrameLengthTest, TestSize.Level0)
1912 {
1913 int32_t osType = TEST_OS_TYPE;
1914 uint32_t packetSize;
1915 int32_t ret = CheckFrameLength(1, PROXY_BR_MAX_PACKET_SIZE, osType, &packetSize);
1916 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
1917
1918 ChannelInfo *channel1 = static_cast<ChannelInfo *>(SoftBusCalloc(sizeof(ChannelInfo)));
1919 ASSERT_TRUE(channel1 != nullptr);
1920 channel1->channelId = 1;
1921 channel1->isEncrypt = 0;
1922 channel1->linkType = LANE_BR;
1923 channel1->sessionKey = const_cast<char *>(g_sessionKey);
1924 ret = ClientTransProxyAddChannelInfo(ClientTransProxyCreateChannelInfo(channel1));
1925 EXPECT_EQ(SOFTBUS_OK, ret);
1926 ret = CheckFrameLength(1, PROXY_BR_MAX_PACKET_SIZE + 1, osType, &packetSize);
1927 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1928 ret = CheckFrameLength(1, PROXY_BR_MAX_PACKET_SIZE - 1, osType, &packetSize);
1929 EXPECT_EQ(SOFTBUS_OK, ret);
1930
1931 ChannelInfo *channel2 = static_cast<ChannelInfo *>(SoftBusCalloc(sizeof(ChannelInfo)));
1932 ASSERT_TRUE(channel2 != nullptr);
1933 channel2->channelId = 2;
1934 channel2->isEncrypt = 0;
1935 channel2->linkType = LANE_BLE_DIRECT;
1936 channel2->sessionKey = const_cast<char *>(g_sessionKey);
1937 ret = ClientTransProxyAddChannelInfo(ClientTransProxyCreateChannelInfo(channel2));
1938 EXPECT_EQ(SOFTBUS_OK, ret);
1939 ret = CheckFrameLength(2, PROXY_BLE_MAX_PACKET_SIZE + 1, osType, &packetSize);
1940 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1941 ret = CheckFrameLength(2, PROXY_BLE_MAX_PACKET_SIZE - 1, osType, &packetSize);
1942 EXPECT_EQ(SOFTBUS_OK, ret);
1943
1944 ret = ClientTransProxyDelChannelInfo(1);
1945 EXPECT_EQ(SOFTBUS_OK, ret);
1946 ret = ClientTransProxyDelChannelInfo(2);
1947 EXPECT_EQ(SOFTBUS_OK, ret);
1948 SoftBusFree(channel1);
1949 SoftBusFree(channel2);
1950 }
1951 } // namespace OHOS