1 /*
2 * Copyright (c) 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_proxy_file_manager.c"
23 #include "client_trans_proxy_file_manager_mock.h"
24 #include "client_trans_proxy_manager.c"
25 #include "softbus_access_token_test.h"
26 #include "softbus_def.h"
27 #include "softbus_error_code.h"
28
29 using namespace testing;
30 using namespace testing::ext;
31
32 #define TEST_SESSION_ID 1026
33 #define TEST_CHANNEL_ID 2058
34 #define TEST_HEADER_LENGTH 24
35 #define TEST_DATA_LENGTH 100
36 #define TEST_PACKET_SIZE 1024
37 #define TEST_FILE_LENGTH 12
38 #define TEST_FILE_DATA_SIZE 958
39 #define TEST_FILE_TEST_TXT_FILE 16
40 #define TEST_SEQ 15
41 #define TEST_ZERO 0
42 #define TEST_NUM 2
43 #define TEST_DATA_LEN 5000
44
45 static const char *TEST_SESSION_NAME = "test.trans.proxy.demo";
46 static const char *TEST_SESSION_KEY = "Test_OpenHarmony";
47
48 namespace OHOS {
49
50 const char *g_testProxyFileList[] = {
51 "/data/test.txt",
52 "/data/ss.txt",
53 };
54
55 class ClientTransProxyFileManagerMockTest : public testing::Test {
56 public:
ClientTransProxyFileManagerMockTest()57 ClientTransProxyFileManagerMockTest() {}
~ClientTransProxyFileManagerMockTest()58 ~ClientTransProxyFileManagerMockTest() {}
59 static void SetUpTestCase(void);
60 static void TearDownTestCase(void);
SetUp()61 void SetUp() override {}
TearDown()62 void TearDown() override {}
63 };
64
SetUpTestCase(void)65 void ClientTransProxyFileManagerMockTest::SetUpTestCase(void)
66 {
67 NiceMock<ClientTransProxyFileManagerInterfaceMock> ClientProxyFileManagerMock;
68 EXPECT_CALL(ClientProxyFileManagerMock, InitPendingPacket).WillRepeatedly(Return(SOFTBUS_OK));
69 int32_t ret = ClinetTransProxyFileManagerInit();
70 EXPECT_EQ(SOFTBUS_OK, ret);
71 ClientTransProxyListInit();
72 }
73
TearDownTestCase(void)74 void ClientTransProxyFileManagerMockTest::TearDownTestCase(void)
75 {
76 ClinetTransProxyFileManagerDeinit();
77 ClientTransProxyListDeinit();
78 }
79
TestCreatInfo(void)80 ClientProxyChannelInfo *TestCreatInfo(void)
81 {
82 ClientProxyChannelInfo *info = (ClientProxyChannelInfo *)SoftBusCalloc(sizeof(ClientProxyChannelInfo));
83 if (info == nullptr) {
84 return nullptr;
85 }
86 info->channelId = TEST_CHANNEL_ID;
87 info->detail.linkType = LANE_HML;
88 info->detail.osType = OH_TYPE;
89 info->detail.isEncrypted = true;
90 return info;
91 }
92
93 /**
94 * @tc.name: AddSendListenerInfoTest001
95 * @tc.desc: client add send listener info, use normal parameter.
96 * @tc.type: FUNC
97 * @tc.require:
98 */
99 HWTEST_F(ClientTransProxyFileManagerMockTest, AddSendListenerInfoTest001, TestSize.Level0)
100 {
101 // will free in DelSendListenerInfo
102 SendListenerInfo *info = (SendListenerInfo *)SoftBusCalloc(sizeof(SendListenerInfo));
103 EXPECT_TRUE(info != nullptr);
104 info->sessionId = TEST_SESSION_ID;
105
106 int32_t ret = AddSendListenerInfo(nullptr);
107 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
108
109 ret = AddSendListenerInfo(info);
110 EXPECT_EQ(SOFTBUS_OK, ret);
111
112 ret = AddSendListenerInfo(info);
113 EXPECT_EQ(SOFTBUS_ALREADY_EXISTED, ret);
114
115 ReleaseSendListenerInfo(info);
116 }
117
118 /**
119 * @tc.name: PackFileTransStartInfoTest001
120 * @tc.desc: client trans proxy pack file data frame test, use normal parameter.
121 * @tc.type: FUNC
122 * @tc.require:
123 */
124 HWTEST_F(ClientTransProxyFileManagerMockTest, PackFileTransStartInfoTest001, TestSize.Level0)
125 {
126 uint8_t data[TEST_DATA_LENGTH] = {0};
127 FileFrame fileFrame = {
128 .frameLength = TEST_HEADER_LENGTH,
129 .data = data,
130 .fileData = data,
131 };
132 SendListenerInfo info = {
133 .crc = APP_INFO_FILE_FEATURES_SUPPORT,
134 .osType = OH_TYPE,
135 .packetSize = 1,
136 };
137
138 int32_t ret = PackFileTransStartInfo(nullptr, g_testProxyFileList[0], TEST_FILE_TEST_TXT_FILE, &info);
139 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
140
141 ret = PackFileTransStartInfo(&fileFrame, nullptr, TEST_FILE_TEST_TXT_FILE, &info);
142 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
143
144 ret = PackFileTransStartInfo(&fileFrame, g_testProxyFileList[0], TEST_FILE_TEST_TXT_FILE, nullptr);
145 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
146
147 ret = PackFileTransStartInfo(&fileFrame, g_testProxyFileList[0], TEST_FILE_TEST_TXT_FILE, &info);
148 EXPECT_EQ(SOFTBUS_TRANS_INVALID_DATA_LENGTH, ret);
149
150 info.packetSize = PROXY_BLE_MAX_PACKET_SIZE;
151 NiceMock<ClientTransProxyFileManagerInterfaceMock> ClientProxyFileManagerMock;
152 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusHtoLl).WillRepeatedly(Return(FILE_MAGIC_NUMBER));
153 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusHtoLll).WillRepeatedly(
154 Return(FILE_MAGIC_NUMBER + FRAME_MAGIC_OFFSET));
155 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusHtoLl).WillRepeatedly(Return(TEST_FILE_DATA_SIZE));
156 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusHtoLll).WillRepeatedly(Return(TEST_FILE_TEST_TXT_FILE));
157
158 ret = PackFileTransStartInfo(&fileFrame, g_testProxyFileList[0], TEST_FILE_TEST_TXT_FILE, &info);
159 EXPECT_EQ(SOFTBUS_OK, ret);
160 }
161
162 /**
163 * @tc.name: UnpackFileTransStartInfoTest001
164 * @tc.desc: client trans proxy pack file data frame test, use normal parameter.
165 * @tc.type: FUNC
166 * @tc.require:
167 */
168 HWTEST_F(ClientTransProxyFileManagerMockTest, UnpackFileTransStartInfoTest001, TestSize.Level0)
169 {
170 uint32_t packetSize = TEST_PACKET_SIZE;
171
172 uint8_t data[TEST_DATA_LENGTH] = {0};
173 FileFrame fileFrame = {
174 .frameLength = TEST_HEADER_LENGTH,
175 .data = data,
176 .fileData = data,
177 };
178 FileRecipientInfo info;
179 info.crc = APP_INFO_FILE_FEATURES_SUPPORT;
180 info.osType = OH_TYPE;
181 SingleFileInfo singleFileInfo;
182 int32_t ret = UnpackFileTransStartInfo(nullptr, &info, &singleFileInfo, packetSize);
183 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
184 ret = UnpackFileTransStartInfo(&fileFrame, nullptr, &singleFileInfo, packetSize);
185 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
186 ret = UnpackFileTransStartInfo(&fileFrame, &info, nullptr, packetSize);
187 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
188
189 NiceMock<ClientTransProxyFileManagerInterfaceMock> ClientProxyFileManagerMock;
190 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusLtoHl).WillOnce(Return(FILE_MAGIC_NUMBER))
191 .WillRepeatedly(Return(TEST_FILE_LENGTH));
192 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusLtoHll).WillOnce(Return(TEST_FILE_LENGTH))
193 .WillRepeatedly(Return(MAX_FILE_SIZE));
194
195 ret = UnpackFileTransStartInfo(&fileFrame, &info, &singleFileInfo, packetSize);
196 EXPECT_EQ(SOFTBUS_OK, ret);
197
198 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusLtoHl).WillOnce(Return(FILE_MAGIC_NUMBER))
199 .WillRepeatedly(Return(TEST_FILE_LENGTH));
200 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusLtoHll).WillOnce(Return(TEST_FILE_LENGTH))
201 .WillRepeatedly(Return(MAX_FILE_SIZE + 1));
202 ret = UnpackFileTransStartInfo(&fileFrame, &info, &singleFileInfo, packetSize);
203 EXPECT_EQ(SOFTBUS_TRANS_INVALID_DATA_LENGTH, ret);
204
205 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusLtoHl).WillOnce(Return(FILE_MAGIC_NUMBER))
206 .WillRepeatedly(Return(TEST_FILE_LENGTH));
207 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusLtoHll).WillOnce(Return(TEST_DATA_LENGTH))
208 .WillRepeatedly(Return(MAX_FILE_SIZE + 1));
209 ret = UnpackFileTransStartInfo(&fileFrame, &info, &singleFileInfo, packetSize);
210 EXPECT_EQ(SOFTBUS_TRANS_INVALID_DATA_LENGTH, ret);
211
212 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusLtoHl).WillOnce(Return(FILE_MAGIC_NUMBER))
213 .WillRepeatedly(Return(TEST_SESSION_ID));
214 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusLtoHll).WillOnce(Return(TEST_FILE_LENGTH))
215 .WillRepeatedly(Return(MAX_FILE_SIZE + 1));
216 ret = UnpackFileTransStartInfo(&fileFrame, &info, &singleFileInfo, packetSize);
217 EXPECT_EQ(SOFTBUS_TRANS_INVALID_DATA_LENGTH, ret);
218 }
219
220 /**
221 * @tc.name: GetAndCheckFileSizeTest001
222 * @tc.desc: client get and check file size, use normal parameter.
223 * @tc.type: FUNC
224 * @tc.require:
225 */
226 HWTEST_F(ClientTransProxyFileManagerMockTest, GetAndCheckFileSizeTest001, TestSize.Level0)
227 {
228 uint64_t fileSize = MAX_FILE_SIZE + 1;
229 uint64_t frameNum = 1;
230 int32_t crc = APP_INFO_FILE_FEATURES_NO_SUPPORT;
231 uint32_t packetSize = FRAME_DATA_SEQ_OFFSET;
232 int32_t ret = GetAndCheckFileSize(nullptr, &fileSize, &frameNum, crc, packetSize);
233 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
234 ret = GetAndCheckFileSize(g_testProxyFileList[0], nullptr, &frameNum, crc, packetSize);
235 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
236 ret = GetAndCheckFileSize(g_testProxyFileList[0], &fileSize, nullptr, crc, packetSize);
237 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
238 NiceMock<ClientTransProxyFileManagerInterfaceMock> ClientProxyFileManagerMock;
239 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusGetFileSize).WillOnce(Return(SOFTBUS_INVALID_PARAM));
240 ret = GetAndCheckFileSize(g_testProxyFileList[0], &fileSize, &frameNum, crc, packetSize);
241 EXPECT_EQ(SOFTBUS_FILE_ERR, ret);
242
243 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusGetFileSize).WillRepeatedly(Return(SOFTBUS_OK));
244 ret = GetAndCheckFileSize(g_testProxyFileList[0], &fileSize, &frameNum, crc, packetSize);
245 EXPECT_EQ(SOFTBUS_FILE_ERR, ret);
246 fileSize = MAX_FILE_SIZE;
247 ret = GetAndCheckFileSize(g_testProxyFileList[0], &fileSize, &frameNum, crc, packetSize);
248 EXPECT_EQ(SOFTBUS_FILE_ERR, ret);
249 packetSize = FRAME_DATA_SEQ_OFFSET + 1;
250 ret = GetAndCheckFileSize(g_testProxyFileList[0], &fileSize, &frameNum, crc, packetSize);
251 EXPECT_EQ(SOFTBUS_OK, ret);
252 }
253
254 /**
255 * @tc.name: SendOneFrameMiddleTest001
256 * @tc.desc: client send one frame middle test, use normal parameter.
257 * @tc.type: FUNC
258 * @tc.require:
259 */
260 HWTEST_F(ClientTransProxyFileManagerMockTest, SendOneFrameMiddleTest001, TestSize.Level0)
261 {
262 SendListenerInfo info = {
263 .crc = APP_INFO_FILE_FEATURES_NO_SUPPORT,
264 .seq = FILE_SEND_ACK_INTERVAL,
265 };
266 int32_t frameType = TRANS_SESSION_FILE_FIRST_FRAME;
267 int32_t ret = SendOneFrameMiddle(nullptr, frameType);
268 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
269 ret = SendOneFrameMiddle(&info, frameType);
270 EXPECT_EQ(SOFTBUS_OK, ret);
271 info.crc = APP_INFO_FILE_FEATURES_SUPPORT;
272 ret = SendOneFrameMiddle(&info, frameType);
273 EXPECT_EQ(SOFTBUS_OK, ret);
274 }
275
276 /**
277 * @tc.name: SendOneFrameRearTest001
278 * @tc.desc: client send one frame rear test, use normal parameter.
279 * @tc.type: FUNC
280 * @tc.require:
281 */
282 HWTEST_F(ClientTransProxyFileManagerMockTest, SendOneFrameRearTest001, TestSize.Level0)
283 {
284 SendListenerInfo info = {
285 .crc = APP_INFO_FILE_FEATURES_NO_SUPPORT,
286 .seq = FILE_SEND_ACK_INTERVAL,
287 .waitSeq = 0,
288 .waitTimeoutCount = WAIT_FRAME_ACK_TIMEOUT_COUNT,
289 };
290 int32_t frameType = TRANS_SESSION_FILE_ONLYONE_FRAME;
291 int32_t ret = SendOneFrameRear(nullptr, frameType);
292 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
293 ret = SendOneFrameRear(&info, frameType);
294 EXPECT_EQ(SOFTBUS_OK, ret);
295 info.crc = APP_INFO_FILE_FEATURES_SUPPORT;
296 ret = SendOneFrameRear(&info, frameType);
297 EXPECT_EQ(SOFTBUS_OK, ret);
298 frameType = TRANS_SESSION_FILE_FIRST_FRAME;
299 NiceMock<ClientTransProxyFileManagerInterfaceMock> ClientProxyFileManagerMock;
300 EXPECT_CALL(ClientProxyFileManagerMock, GetPendingPacketData).WillOnce(Return(SOFTBUS_OK))
301 .WillOnce(Return(SOFTBUS_ALREADY_TRIGGERED)).WillOnce(Return(SOFTBUS_TIMOUT)).WillOnce(Return(SOFTBUS_OK))
302 .WillOnce(Return(SOFTBUS_ALREADY_TRIGGERED)).WillRepeatedly(Return(SOFTBUS_TIMOUT));
303 ret = SendOneFrameRear(&info, frameType);
304 EXPECT_EQ(SOFTBUS_OK, ret);
305 ret = SendOneFrameRear(&info, frameType);
306 EXPECT_EQ(SOFTBUS_OK, ret);
307 ret = SendOneFrameRear(&info, frameType);
308 EXPECT_EQ(SOFTBUS_FILE_ERR, ret);
309 frameType = TRANS_SESSION_FILE_LAST_FRAME;
310 ret = SendOneFrameRear(&info, frameType);
311 EXPECT_EQ(SOFTBUS_OK, ret);
312 info.waitSeq = 1;
313 ret = SendOneFrameRear(&info, frameType);
314 EXPECT_EQ(SOFTBUS_OK, ret);
315 info.waitSeq = 1;
316 ret = SendOneFrameRear(&info, frameType);
317 EXPECT_EQ(SOFTBUS_OK, ret);
318 info.waitSeq = 1;
319 ret = SendOneFrameRear(&info, frameType);
320 EXPECT_EQ(SOFTBUS_FILE_ERR, ret);
321 frameType = TRANS_SESSION_ACK;
322 info.waitSeq = 1;
323 ret = SendOneFrameRear(&info, frameType);
324 EXPECT_EQ(SOFTBUS_OK, ret);
325 info.waitTimeoutCount = WAIT_FRAME_ACK_TIMEOUT_COUNT - 1;
326 ret = SendOneFrameRear(&info, frameType);
327 EXPECT_EQ(SOFTBUS_OK, ret);
328 }
329
330 /**
331 * @tc.name: SendFileCrcCheckSumTest001
332 * @tc.desc: client send file crc check sum, use normal parameter.
333 * @tc.type: FUNC
334 * @tc.require:
335 */
336 HWTEST_F(ClientTransProxyFileManagerMockTest, SendFileCrcCheckSumTest001, TestSize.Level0)
337 {
338 SendListenerInfo info = {
339 .crc = APP_INFO_FILE_FEATURES_NO_SUPPORT,
340 .seq = FILE_SEND_ACK_INTERVAL,
341 .osType = OH_TYPE,
342 .checkSumCRC = TEST_FILE_TEST_TXT_FILE,
343 };
344 int32_t ret = SendFileCrcCheckSum(nullptr);
345 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
346 ret = SendFileCrcCheckSum(&info);
347 EXPECT_EQ(SOFTBUS_OK, ret);
348 info.crc = APP_INFO_FILE_FEATURES_SUPPORT;
349 NiceMock<ClientTransProxyFileManagerInterfaceMock> ClientProxyFileManagerMock;
350 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusHtoLl).WillOnce(Return(FILE_MAGIC_NUMBER))
351 .WillRepeatedly(Return(FILE_SEND_ACK_INTERVAL + 1));
352 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusHtoLll).WillOnce(Return(TEST_FILE_LENGTH))
353 .WillRepeatedly(Return(TEST_FILE_TEST_TXT_FILE));
354 EXPECT_CALL(ClientProxyFileManagerMock, CreatePendingPacket).WillOnce(Return(SOFTBUS_INVALID_PARAM));
355 ret = SendFileCrcCheckSum(&info);
356 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
357 }
358
359 /**
360 * @tc.name: UnpackFileCrcCheckSumTest001
361 * @tc.desc: client unpack file crc check sum, use normal parameter.
362 * @tc.type: FUNC
363 * @tc.require:
364 */
365 HWTEST_F(ClientTransProxyFileManagerMockTest, UnpackFileCrcCheckSumTest001, TestSize.Level0)
366 {
367 SendListenerInfo fileInfo = {
368 .checkSumCRC = TEST_FILE_DATA_SIZE,
369 };
370 FileRecipientInfo info = {
371 .crc = APP_INFO_FILE_FEATURES_SUPPORT,
372 .osType = OH_TYPE,
373 };
374 (void)memcpy_s(&info.recvFileInfo, sizeof(SendListenerInfo), &fileInfo, sizeof(SendListenerInfo));
375 uint8_t data[TEST_DATA_LENGTH] = {0};
376 FileFrame fileFrame = {
377 .frameLength = TEST_FILE_LENGTH,
378 .data = data,
379 .fileData = data,
380 };
381 int32_t ret = UnpackFileCrcCheckSum(nullptr, &fileFrame);
382 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
383 ret = UnpackFileCrcCheckSum(&info, nullptr);
384 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
385 ret = UnpackFileCrcCheckSum(&info, &fileFrame);
386 EXPECT_EQ(SOFTBUS_TRANS_INVALID_DATA_LENGTH, ret);
387 fileFrame.frameLength = FRAME_HEAD_LEN + FRAME_DATA_SEQ_OFFSET + sizeof(uint64_t);
388 NiceMock<ClientTransProxyFileManagerInterfaceMock> ClientProxyFileManagerMock;
389 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusLtoHl).WillOnce(Return(TEST_DATA_LENGTH));
390 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusLtoHll).WillOnce(Return(TEST_DATA_LENGTH));
391 ret = UnpackFileCrcCheckSum(&info, &fileFrame);
392 EXPECT_EQ(SOFTBUS_INVALID_DATA_HEAD, ret);
393 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusLtoHl).WillOnce(Return(FILE_MAGIC_NUMBER));
394 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusLtoHll).WillOnce(Return(TEST_DATA_LENGTH));
395 ret = UnpackFileCrcCheckSum(&info, &fileFrame);
396 EXPECT_EQ(SOFTBUS_INVALID_DATA_HEAD, ret);
397
398 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusLtoHl).WillOnce(Return(FILE_MAGIC_NUMBER))
399 .WillRepeatedly(Return(FILE_SEND_ACK_INTERVAL + 1));
400 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusLtoHll)
401 .WillOnce(Return(FRAME_DATA_SEQ_OFFSET + sizeof(uint64_t)))
402 .WillRepeatedly(Return(FILE_SEND_ACK_INTERVAL + 1));
403 ret = UnpackFileCrcCheckSum(&info, &fileFrame);
404 EXPECT_EQ(SOFTBUS_FILE_ERR, ret);
405
406 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusLtoHl).WillOnce(Return(FILE_MAGIC_NUMBER))
407 .WillRepeatedly(Return(FILE_SEND_ACK_INTERVAL + 1));
408 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusLtoHll)
409 .WillOnce(Return(FRAME_DATA_SEQ_OFFSET + sizeof(uint64_t)))
410 .WillRepeatedly(Return(TEST_ZERO));
411 ret = UnpackFileCrcCheckSum(&info, &fileFrame);
412 EXPECT_EQ(SOFTBUS_OK, ret);
413 }
414
415 /**
416 * @tc.name: FileToFrameTest001
417 * @tc.desc: client send file crc check sum, use normal parameter.
418 * @tc.type: FUNC
419 * @tc.require:
420 */
421 HWTEST_F(ClientTransProxyFileManagerMockTest, FileToFrameTest001, TestSize.Level0)
422 {
423 SendListenerInfo sendInfo = {
424 .crc = APP_INFO_FILE_FEATURES_SUPPORT,
425 .seq = FILE_SEND_ACK_INTERVAL,
426 .osType = OH_TYPE,
427 .checkSumCRC = TEST_FILE_TEST_TXT_FILE,
428 .packetSize = TEST_HEADER_LENGTH,
429 };
430 uint64_t frameNum = TEST_NUM;
431 NiceMock<ClientTransProxyFileManagerInterfaceMock> ClientProxyFileManagerMock;
432 EXPECT_CALL(ClientProxyFileManagerMock, FrameIndexToType).WillRepeatedly(Return(TRANS_SESSION_FILE_ONLYONE_FRAME));
433 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusHtoLl).WillRepeatedly(Return(FILE_MAGIC_NUMBER));
434 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusHtoLll).WillRepeatedly(Return(
435 FILE_MAGIC_NUMBER + FRAME_MAGIC_OFFSET));
436 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusHtoLl).WillRepeatedly(Return(TEST_FILE_DATA_SIZE));
437 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusHtoLll).WillRepeatedly(Return(TEST_FILE_TEST_TXT_FILE));
438 int32_t ret = FileToFrame(&sendInfo, frameNum, g_testProxyFileList[0], TEST_FILE_TEST_TXT_FILE);
439 EXPECT_EQ(SOFTBUS_FILE_ERR, ret);
440 frameNum = 0;
441 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusHtoLl).WillOnce(Return(FILE_MAGIC_NUMBER))
442 .WillRepeatedly(Return(FILE_SEND_ACK_INTERVAL + 1));
443 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusHtoLll).WillOnce(Return(TEST_FILE_LENGTH))
444 .WillRepeatedly(Return(TEST_FILE_TEST_TXT_FILE));
445 EXPECT_CALL(ClientProxyFileManagerMock, CreatePendingPacket).WillOnce(Return(SOFTBUS_INVALID_PARAM));
446 ret = FileToFrame(&sendInfo, frameNum, g_testProxyFileList[0], TEST_FILE_TEST_TXT_FILE);
447 EXPECT_EQ(SOFTBUS_FILE_ERR, ret);
448 sendInfo.osType = TEST_ZERO;
449 ret = FileToFrame(&sendInfo, frameNum, g_testProxyFileList[0], TEST_FILE_TEST_TXT_FILE);
450 EXPECT_EQ(SOFTBUS_OK, ret);
451 }
452
453 /**
454 * @tc.name: FileToFrameAndSendFileTest001
455 * @tc.desc: client send file crc check sum, use normal parameter.
456 * @tc.type: FUNC
457 * @tc.require:
458 */
459 HWTEST_F(ClientTransProxyFileManagerMockTest, FileToFrameAndSendFileTest001, TestSize.Level0)
460 {
461 SendListenerInfo sendInfo = {
462 .crc = APP_INFO_FILE_FEATURES_NO_SUPPORT,
463 .seq = FILE_SEND_ACK_INTERVAL,
464 .osType = OH_TYPE,
465 .checkSumCRC = TEST_FILE_TEST_TXT_FILE,
466 .packetSize = FRAME_DATA_SEQ_OFFSET + 1,
467 };
468 NiceMock<ClientTransProxyFileManagerInterfaceMock> ClientProxyFileManagerMock;
469 EXPECT_CALL(ClientProxyFileManagerMock, CheckDestFilePathValid).WillOnce(Return(false));
470 int32_t ret = FileToFrameAndSendFile(&sendInfo, g_testProxyFileList[0], g_testProxyFileList[1]);
471 EXPECT_EQ(SOFTBUS_FILE_ERR, ret);
472 EXPECT_CALL(ClientProxyFileManagerMock, CheckDestFilePathValid).WillRepeatedly(Return(true));
473 EXPECT_CALL(ClientProxyFileManagerMock, GetAndCheckRealPath).WillOnce(Return(SOFTBUS_INVALID_PARAM));
474 ret = FileToFrameAndSendFile(&sendInfo, g_testProxyFileList[0], g_testProxyFileList[1]);
475 EXPECT_EQ(SOFTBUS_FILE_ERR, ret);
476 EXPECT_CALL(ClientProxyFileManagerMock, GetAndCheckRealPath).WillRepeatedly(Return(SOFTBUS_OK));
477 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusGetFileSize).WillOnce(Return(SOFTBUS_INVALID_PARAM));
478 ret = FileToFrameAndSendFile(&sendInfo, g_testProxyFileList[0], g_testProxyFileList[1]);
479 EXPECT_EQ(SOFTBUS_FILE_ERR, ret);
480 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusGetFileSize).WillRepeatedly(Return(SOFTBUS_OK));
481 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusOpenFile).WillOnce(Return(-1));
482 ret = FileToFrameAndSendFile(&sendInfo, g_testProxyFileList[0], g_testProxyFileList[1]);
483 EXPECT_EQ(SOFTBUS_FILE_ERR, ret);
484 sendInfo.osType = TEST_ZERO;
485 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusOpenFile).WillRepeatedly(Return(1));
486 EXPECT_CALL(ClientProxyFileManagerMock, TryFileLock).WillOnce(Return(SOFTBUS_OK));
487 ret = FileToFrameAndSendFile(&sendInfo, g_testProxyFileList[0], g_testProxyFileList[1]);
488 EXPECT_EQ(SOFTBUS_FILE_ERR, ret);
489 }
490
491 /**
492 * @tc.name: ClearSendInfoTest001
493 * @tc.desc: client send file crc check sum, use normal parameter.
494 * @tc.type: FUNC
495 * @tc.require:
496 */
497 HWTEST_F(ClientTransProxyFileManagerMockTest, ClearSendInfoTest001, TestSize.Level0)
498 {
499 SendListenerInfo testSendInfo = {
500 .fd = -1,
501 .fileSize = 1,
502 };
503 ClearSendInfo(&testSendInfo);
504 EXPECT_EQ(0, testSendInfo.fileSize);
505 }
506
507 /**
508 * @tc.name: GetFileSizeTest001
509 * @tc.desc: client send file crc check sum, use normal parameter.
510 * @tc.type: FUNC
511 * @tc.require:
512 */
513 HWTEST_F(ClientTransProxyFileManagerMockTest, GetFileSizeTest001, TestSize.Level0)
514 {
515 uint64_t fileSize = TEST_PACKET_SIZE;
516 NiceMock<ClientTransProxyFileManagerInterfaceMock> ClientProxyFileManagerMock;
517 EXPECT_CALL(ClientProxyFileManagerMock, GetAndCheckRealPath).WillRepeatedly(Return(SOFTBUS_OK));
518 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusGetFileSize).WillOnce(Return(SOFTBUS_INVALID_PARAM));
519 int32_t ret = GetFileSize(g_testProxyFileList[0], &fileSize);
520 EXPECT_EQ(SOFTBUS_FILE_ERR, ret);
521
522 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusGetFileSize).WillOnce(Return(SOFTBUS_OK));
523 ret = GetFileSize(g_testProxyFileList[0], &fileSize);
524 EXPECT_EQ(SOFTBUS_OK, ret);
525 }
526
527 /**
528 * @tc.name: ProxyStartSendFileTest001
529 * @tc.desc: client send file crc check sum, use normal parameter.
530 * @tc.type: FUNC
531 * @tc.require:
532 */
533 HWTEST_F(ClientTransProxyFileManagerMockTest, ProxyStartSendFileTest001, TestSize.Level0)
534 {
535 SendListenerInfo testSendInfo = {
536 .fd = -1,
537 .fileSize = 1,
538 };
539 uint32_t fileCnt = 1;
540 NiceMock<ClientTransProxyFileManagerInterfaceMock> ClientProxyFileManagerMock;
541 EXPECT_CALL(ClientProxyFileManagerMock, GetAndCheckRealPath).WillRepeatedly(Return(SOFTBUS_OK));
542 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusGetFileSize).WillOnce(Return(SOFTBUS_INVALID_PARAM));
543 int32_t ret = ProxyStartSendFile(&testSendInfo, &g_testProxyFileList[0], &g_testProxyFileList[1], fileCnt);
544 EXPECT_EQ(SOFTBUS_FILE_ERR, ret);
545
546 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusGetFileSize).WillRepeatedly(Return(SOFTBUS_OK));
547 EXPECT_CALL(ClientProxyFileManagerMock, CheckDestFilePathValid).WillOnce(Return(false));
548 ret = ProxyStartSendFile(&testSendInfo, &g_testProxyFileList[0], &g_testProxyFileList[1], fileCnt);
549 EXPECT_EQ(SOFTBUS_FILE_ERR, ret);
550
551 fileCnt = 0;
552 ret = ProxyStartSendFile(&testSendInfo, &g_testProxyFileList[0], &g_testProxyFileList[1], fileCnt);
553 EXPECT_EQ(SOFTBUS_OK, ret);
554 }
555
556 /**
557 * @tc.name: GetSendListenerInfoByChannelIdTest001
558 * @tc.desc: client send file crc check sum, use normal parameter.
559 * @tc.type: FUNC
560 * @tc.require:
561 */
562 HWTEST_F(ClientTransProxyFileManagerMockTest, GetSendListenerInfoByChannelIdTest001, TestSize.Level0)
563 {
564 SendListenerInfo *info = (SendListenerInfo *)SoftBusCalloc(sizeof(SendListenerInfo));
565 EXPECT_TRUE(info != nullptr);
566 info->sessionId = TEST_SESSION_ID;
567 int32_t channelId = TEST_CHANNEL_ID;
568 int32_t osType = OH_TYPE;
569 // will free in ClientTransProxyDelChannelInfo
570 ClientProxyChannelInfo *channelInfo = TestCreatInfo();
571 ASSERT_TRUE(channelInfo != nullptr);
572
573 int32_t ret = GetSendListenerInfoByChannelId(channelId, nullptr, osType);
574 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
575 NiceMock<ClientTransProxyFileManagerInterfaceMock> ClientProxyFileManagerMock;
576 EXPECT_CALL(ClientProxyFileManagerMock, ClientGetSessionIdByChannelId).WillOnce(Return(SOFTBUS_NO_INIT));
577 ret = GetSendListenerInfoByChannelId(channelId, info, osType);
578 EXPECT_EQ(SOFTBUS_NO_INIT, ret);
579
580 EXPECT_CALL(ClientProxyFileManagerMock, ClientGetSessionIdByChannelId).WillRepeatedly(Return(SOFTBUS_OK));
581 EXPECT_CALL(ClientProxyFileManagerMock, ClientGetSessionDataById).WillOnce(Return(SOFTBUS_INVALID_PARAM));
582 ret = GetSendListenerInfoByChannelId(channelId, info, osType);
583 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
584
585 EXPECT_CALL(ClientProxyFileManagerMock, ClientGetSessionDataById).WillRepeatedly(Return(SOFTBUS_OK));
586 EXPECT_CALL(ClientProxyFileManagerMock, ClientGetFileConfigInfoById).WillOnce(Return(SOFTBUS_NO_INIT));
587 ret = GetSendListenerInfoByChannelId(channelId, info, osType);
588 EXPECT_EQ(SOFTBUS_NO_INIT, ret);
589
590 EXPECT_CALL(ClientProxyFileManagerMock, ClientGetFileConfigInfoById).WillRepeatedly(Return(SOFTBUS_OK));
591 EXPECT_CALL(ClientProxyFileManagerMock, TransGetFileListener).WillOnce(Return(SOFTBUS_INVALID_PARAM));
592 ret = GetSendListenerInfoByChannelId(channelId, info, osType);
593 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
594
595 EXPECT_CALL(ClientProxyFileManagerMock, TransGetFileListener).WillRepeatedly(Return(SOFTBUS_OK));
596 ret = GetSendListenerInfoByChannelId(channelId, info, osType);
597 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
598
599 ret = ClientTransProxyAddChannelInfo(channelInfo);
600 EXPECT_EQ(SOFTBUS_OK, ret);
601 ret = GetSendListenerInfoByChannelId(channelId, info, osType);
602 EXPECT_EQ(SOFTBUS_OK, ret);
603 ret = ClientTransProxyDelChannelInfo(TEST_CHANNEL_ID);
604 EXPECT_EQ(SOFTBUS_OK, ret);
605 SoftBusFree(info);
606 }
607
608 /**
609 * @tc.name: CreateSendListenerInfoTest001
610 * @tc.desc: client send file crc check sum, use normal parameter.
611 * @tc.type: FUNC
612 * @tc.require:
613 */
614 HWTEST_F(ClientTransProxyFileManagerMockTest, CreateSendListenerInfoTest001, TestSize.Level0)
615 {
616 // will free in DelSendListenerInfo
617 SendListenerInfo *info = (SendListenerInfo *)SoftBusCalloc(sizeof(SendListenerInfo));
618 EXPECT_TRUE(info != nullptr);
619 info->sessionId = TEST_SESSION_ID;
620 int32_t channelId = TEST_CHANNEL_ID;
621 int32_t osType = OH_TYPE;
622 // will free in ClientTransProxyDelChannelInfo
623 ClientProxyChannelInfo *channelInfo = TestCreatInfo();
624 ASSERT_TRUE(channelInfo != nullptr);
625 int32_t ret = ClientTransProxyAddChannelInfo(channelInfo);
626 EXPECT_EQ(SOFTBUS_OK, ret);
627
628 NiceMock<ClientTransProxyFileManagerInterfaceMock> ClientProxyFileManagerMock;
629 EXPECT_CALL(ClientProxyFileManagerMock, ClientGetSessionIdByChannelId).WillRepeatedly(Return(SOFTBUS_OK));
630 EXPECT_CALL(ClientProxyFileManagerMock, ClientGetSessionDataById).WillRepeatedly(Return(SOFTBUS_OK));
631 EXPECT_CALL(ClientProxyFileManagerMock, ClientGetFileConfigInfoById).WillRepeatedly(Return(SOFTBUS_OK));
632 EXPECT_CALL(ClientProxyFileManagerMock, TransGetFileListener).WillRepeatedly(Return(SOFTBUS_OK));
633 ret = CreateSendListenerInfo(&info, channelId, osType);
634 EXPECT_EQ(SOFTBUS_OK, ret);
635
636 ret = ClientTransProxyDelChannelInfo(TEST_CHANNEL_ID);
637 EXPECT_EQ(SOFTBUS_OK, ret);
638 ReleaseSendListenerInfo(info);
639 }
640
641 /**
642 * @tc.name: HandleFileSendingProcessTest001
643 * @tc.desc: client send file crc check sum, use normal parameter.
644 * @tc.type: FUNC
645 * @tc.require:
646 */
647 HWTEST_F(ClientTransProxyFileManagerMockTest, HandleFileSendingProcessTest001, TestSize.Level0)
648 {
649 int channelId = TEST_CHANNEL_ID;
650 uint32_t fileCnt = 1;
651 // will free in ClientTransProxyDelChannelInfo
652 ClientProxyChannelInfo *channelInfo = TestCreatInfo();
653 ASSERT_TRUE(channelInfo != nullptr);
654 int32_t ret = ClientTransProxyAddChannelInfo(channelInfo);
655 EXPECT_EQ(SOFTBUS_OK, ret);
656
657 NiceMock<ClientTransProxyFileManagerInterfaceMock> ClientProxyFileManagerMock;
658 EXPECT_CALL(ClientProxyFileManagerMock, ClientGetSessionIdByChannelId).WillRepeatedly(Return(SOFTBUS_OK));
659 EXPECT_CALL(ClientProxyFileManagerMock, ClientGetSessionDataById).WillRepeatedly(Return(SOFTBUS_OK));
660 EXPECT_CALL(ClientProxyFileManagerMock, ClientGetFileConfigInfoById).WillRepeatedly(Return(SOFTBUS_OK));
661 EXPECT_CALL(ClientProxyFileManagerMock, TransGetFileListener).WillRepeatedly(Return(SOFTBUS_OK));
662 EXPECT_CALL(ClientProxyFileManagerMock, GetAndCheckRealPath).WillRepeatedly(Return(SOFTBUS_OK));
663 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusGetFileSize).WillRepeatedly(Return(SOFTBUS_OK));
664 EXPECT_CALL(ClientProxyFileManagerMock, CheckDestFilePathValid).WillOnce(Return(false));
665 ret = HandleFileSendingProcess(channelId, &g_testProxyFileList[0], &g_testProxyFileList[1], fileCnt);
666 EXPECT_EQ(SOFTBUS_TRANS_PROXY_SENDMSG_ERR, ret);
667
668 fileCnt = 0;
669 ret = HandleFileSendingProcess(channelId, &g_testProxyFileList[0], &g_testProxyFileList[1], fileCnt);
670 EXPECT_EQ(SOFTBUS_OK, ret);
671
672 ret = ClientTransProxyDelChannelInfo(TEST_CHANNEL_ID);
673 EXPECT_EQ(SOFTBUS_OK, ret);
674 }
675
676 /**
677 * @tc.name: ClientTransProxyAddChannelInfoTest001
678 * @tc.desc: client send file crc check sum, use normal parameter.
679 * @tc.type: FUNC
680 * @tc.require:
681 */
682 HWTEST_F(ClientTransProxyFileManagerMockTest, ClientTransProxyAddChannelInfoTest001, TestSize.Level0)
683 {
684 // will free in ClientTransProxyDelChannelInfo
685 ClientProxyChannelInfo *channelInfo = TestCreatInfo();
686 ASSERT_TRUE(channelInfo != nullptr);
687 int32_t ret = ClientTransProxyAddChannelInfo(nullptr);
688 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
689 ret = ClientTransProxyAddChannelInfo(channelInfo);
690 EXPECT_EQ(SOFTBUS_OK, ret);
691 ret = ClientTransProxyAddChannelInfo(channelInfo);
692 EXPECT_EQ(SOFTBUS_ALREADY_EXISTED, ret);
693
694 ret = ClientTransProxyDelChannelInfo(TEST_CHANNEL_ID);
695 EXPECT_EQ(SOFTBUS_OK, ret);
696 }
697
698 /**
699 * @tc.name: ClientTransProxyOnChannelOpenedTest001
700 * @tc.desc: client send file crc check sum, use normal parameter.
701 * @tc.type: FUNC
702 * @tc.require:
703 */
704 HWTEST_F(ClientTransProxyFileManagerMockTest, ClientTransProxyOnChannelOpenedTest001, TestSize.Level0)
705 {
706 ChannelInfo channel = {
707 .channelId = TEST_CHANNEL_ID,
708 .isEncrypt = true,
709 .linkType = LANE_HML,
710 .osType = OH_TYPE,
711 .sessionKey = const_cast<char *>(TEST_SESSION_KEY),
712 };
713 // will free in ClientTransProxyDelChannelInfo
714 ClientProxyChannelInfo *channelInfo = TestCreatInfo();
715 ASSERT_TRUE(channelInfo != nullptr);
716 int32_t ret = ClientTransProxyAddChannelInfo(channelInfo);
717 EXPECT_EQ(SOFTBUS_OK, ret);
718 ret = ClientTransProxyOnChannelOpened(TEST_SESSION_NAME, &channel);
719 EXPECT_EQ(SOFTBUS_ALREADY_EXISTED, ret);
720 ret = ClientTransProxyDelChannelInfo(TEST_CHANNEL_ID);
721 EXPECT_EQ(SOFTBUS_OK, ret);
722 }
723
724 /**
725 * @tc.name: ClientTransProxySessionDataLenCheckTest001
726 * @tc.desc: client send file crc check sum, use normal parameter.
727 * @tc.type: FUNC
728 * @tc.require:
729 */
730 HWTEST_F(ClientTransProxyFileManagerMockTest, ClientTransProxySessionDataLenCheckTest001, TestSize.Level0)
731 {
732 uint32_t len = TEST_DATA_LEN;
733 SessionPktType type = TRANS_SESSION_MESSAGE;
734 int32_t ret = ClientTransProxySessionDataLenCheck(len, type);
735 EXPECT_EQ(SOFTBUS_TRANS_INVALID_DATA_LENGTH, ret);
736 type = TRANS_SESSION_BYTES;
737 ret = ClientTransProxySessionDataLenCheck(len, type);
738 EXPECT_EQ(SOFTBUS_TRANS_INVALID_DATA_LENGTH, ret);
739 type = TRANS_SESSION_FILE_LAST_FRAME;
740 ret = ClientTransProxySessionDataLenCheck(len, type);
741 EXPECT_EQ(SOFTBUS_OK, ret);
742 len = 0;
743 type = TRANS_SESSION_ASYNC_MESSAGE;
744 ret = ClientTransProxySessionDataLenCheck(len, type);
745 EXPECT_EQ(SOFTBUS_OK, ret);
746 type = TRANS_SESSION_BYTES;
747 ret = ClientTransProxySessionDataLenCheck(len, type);
748 EXPECT_EQ(SOFTBUS_OK, ret);
749 }
750
751 /**
752 * @tc.name: ClientTransProxyDecryptPacketDataTest001
753 * @tc.desc: client send file crc check sum, use normal parameter.
754 * @tc.type: FUNC
755 * @tc.require:
756 */
757 HWTEST_F(ClientTransProxyFileManagerMockTest, ClientTransProxyDecryptPacketDataTest001, TestSize.Level0)
758 {
759 int32_t channelId = TEST_CHANNEL_ID;
760 int32_t seq = TEST_SEQ;
761 ClientProxyDataInfo dataInfo;
762 int32_t ret = ClientTransProxyDecryptPacketData(channelId, seq, &dataInfo);
763 EXPECT_EQ(SOFTBUS_TRANS_PROXY_CHANNEL_NOT_FOUND, ret);
764
765 ret = ClientTransProxyCheckSliceHead(nullptr);
766 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
767 }
768
769 /**
770 * @tc.name: ClientTransProxyProcSendMsgAckTest001
771 * @tc.desc: client send file crc check sum, use normal parameter.
772 * @tc.type: FUNC
773 * @tc.require:
774 */
775 HWTEST_F(ClientTransProxyFileManagerMockTest, ClientTransProxyProcSendMsgAckTest001, TestSize.Level0)
776 {
777 int32_t channelId = TEST_CHANNEL_ID;
778 int32_t len = TEST_DATA_LEN;
779 int32_t dataHeadSeq = TEST_DATA_LEN;
780 int32_t ret = ClientTransProxyProcSendMsgAck(channelId, TEST_SESSION_NAME, len, dataHeadSeq, 0);
781 EXPECT_EQ(SOFTBUS_TRANS_INVALID_DATA_LENGTH, ret);
782
783 len = PROXY_ACK_SIZE;
784 ret = ClientTransProxyProcSendMsgAck(channelId, nullptr, len, dataHeadSeq, 0);
785 EXPECT_EQ(SOFTBUS_TRANS_PROXY_ASSEMBLE_PACK_DATA_NULL, ret);
786 }
787 } // namespace OHOS