1 /*
2 * Copyright (c) 2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "gtest/gtest.h"
17 #include <securec.h>
18
19 #include "trans_proxy_process_data.h"
20 #include "trans_proxy_process_data.c"
21 #include "trans_tcp_process_data.h"
22 #include "trans_tcp_process_data.c"
23
24 using namespace testing::ext;
25
26 namespace OHOS {
27 #define TEST_CHANNEL_ID 1124
28
29 class TransProcessDataTest : public testing::Test {
30 public:
TransProcessDataTest()31 TransProcessDataTest()
32 {}
~TransProcessDataTest()33 ~TransProcessDataTest()
34 {}
35 static void SetUpTestCase(void);
36 static void TearDownTestCase(void);
SetUp()37 void SetUp() override
38 {}
TearDown()39 void TearDown() override
40 {}
41 };
42
SetUpTestCase(void)43 void TransProcessDataTest::SetUpTestCase(void) {}
44
TearDownTestCase(void)45 void TransProcessDataTest::TearDownTestCase(void) {}
46
47 /**
48 * @tc.name: TransProcessDataTest001
49 * @tc.desc: Transmission session manager initialize.
50 * @tc.type: FUNC
51 * @tc.require:
52 */
53 HWTEST_F(TransProcessDataTest, TransProcessDataTest001, TestSize.Level1)
54 {
55 TransUnPackTlvPackHead(nullptr);
56 TransUnPackSliceHead(nullptr);
57
58 int32_t channelId = TEST_CHANNEL_ID;
59 SessionPktType flag = TRANS_SESSION_BYTES;
60 int32_t seq = 1;
61 int32_t ret = TransProxyPackBytes(channelId, nullptr, nullptr, flag, seq);
62 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
63
64 ProxyDataInfo *dataInfo = static_cast<ProxyDataInfo *>(SoftBusCalloc(sizeof(ProxyDataInfo)));
65 EXPECT_NE(nullptr, dataInfo);
66 const char *sessionkey = "testSessionKey";
67 ret = TransProxyPackBytes(channelId, dataInfo, sessionkey, flag, seq);
68 EXPECT_EQ(SOFTBUS_TRANS_PROXY_SESS_ENCRYPT_ERR, ret);
69
70 SoftBusFree(dataInfo);
71 }
72
73 /**
74 * @tc.name: TransProcessDataTest002
75 * @tc.desc: Transmission session manager initialize.
76 * @tc.type: FUNC
77 * @tc.require:
78 */
79 HWTEST_F(TransProcessDataTest, TransProcessDataTest002, TestSize.Level1)
80 {
81 int32_t finalSeq = 1;
82 int32_t flagTest = 1;
83 uint32_t dataLen = 1;
84 int32_t tlvBufferSize = 1;
85 int32_t ret = ProxyBuildTlvDataHead(nullptr, finalSeq, flagTest, dataLen, &tlvBufferSize);
86 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
87
88 ProxyDataInfo *dataInfo = static_cast<ProxyDataInfo *>(SoftBusCalloc(sizeof(ProxyDataInfo)));
89 EXPECT_NE(nullptr, dataInfo);
90 DataHeadTlvPacketHead *info = static_cast<DataHeadTlvPacketHead *>(SoftBusCalloc(sizeof(DataHeadTlvPacketHead)));
91 EXPECT_NE(nullptr, info);
92 const char *sessionKey = "testSessionKey";
93 SessionPktType flag = TRANS_SESSION_BYTES;
94 int32_t seq = 1;
95 ret = TransProxyPackTlvBytes(nullptr, sessionKey, flag, seq, info);
96 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
97
98 ret = TransProxyPackTlvBytes(dataInfo, nullptr, flag, seq, info);
99 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
100
101 ret = TransProxyPackTlvBytes(dataInfo, sessionKey, flag, seq, nullptr);
102 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
103
104 ret = TransProxyPackTlvBytes(dataInfo, sessionKey, flag, seq, info);
105 EXPECT_EQ(SOFTBUS_TRANS_PROXY_SESS_ENCRYPT_ERR, ret);
106
107 SoftBusFree(dataInfo);
108 SoftBusFree(info);
109 }
110
111 /**
112 * @tc.name: TransProcessDataTest003
113 * @tc.desc: Transmission session manager initialize.
114 * @tc.type: FUNC
115 * @tc.require:
116 */
117 HWTEST_F(TransProcessDataTest, TransProcessDataTest003, TestSize.Level1)
118 {
119 uint32_t sliceNum = 1;
120 SessionPktType pktType = TRANS_SESSION_BYTES;
121 uint32_t cnt = 1;
122 uint32_t dataLen = 1;
123
124 EXPECT_EQ(nullptr, TransProxyPackData(nullptr, sliceNum, pktType, cnt, &dataLen));
125
126 ProxyDataInfo *dataInfo = static_cast<ProxyDataInfo *>(SoftBusCalloc(sizeof(ProxyDataInfo)));
127 EXPECT_NE(nullptr, dataInfo);
128 EXPECT_EQ(nullptr, TransProxyPackData(nullptr, sliceNum, pktType, cnt, &dataLen));
129
130 dataInfo->outLen = SLICE_LEN;
131 EXPECT_EQ(nullptr, TransProxyPackData(nullptr, sliceNum, pktType, cnt, &dataLen));
132 SoftBusFree(dataInfo);
133 }
134
135 /**
136 * @tc.name: TransProcessDataTest004
137 * @tc.desc: Transmission session manager initialize.
138 * @tc.type: FUNC
139 * @tc.require:
140 */
141 HWTEST_F(TransProcessDataTest, TransProcessDataTest004, TestSize.Level1)
142 {
143 uint32_t len = 1;
144 const char *data = "12121212";
145 int32_t channelId = TEST_CHANNEL_ID;
146 int32_t ret = TransProxyNoSubPacketProc(nullptr, len, data, channelId);
147 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
148
149 PacketHead *head = static_cast<PacketHead *>(SoftBusCalloc(sizeof(PacketHead)));
150 EXPECT_NE(nullptr, head);
151 ret = TransProxyNoSubPacketProc(head, len, nullptr, channelId);
152 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
153
154 ret = TransProxyNoSubPacketProc(head, len, data, channelId);
155 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
156
157 len = 1000; // test value
158 ret = TransProxyNoSubPacketProc(head, len, data, channelId);
159 EXPECT_EQ(SOFTBUS_INVALID_DATA_HEAD, ret);
160
161 head->magicNumber = 0xBABEFACE;
162 head->dataLen = 1;
163 ret = TransProxyNoSubPacketProc(head, len, data, channelId);
164 EXPECT_EQ(SOFTBUS_INVALID_DATA_HEAD, ret);
165 SoftBusFree(head);
166 }
167
168 /**
169 * @tc.name: TransProcessDataTest005
170 * @tc.desc: Transmission session manager initialize.
171 * @tc.type: FUNC
172 * @tc.require:
173 */
174 HWTEST_F(TransProcessDataTest, TransProcessDataTest005, TestSize.Level1)
175 {
176 const char *data = "121212"; // test value
177 PacketHead dataHead;
178 (void)memset_s(&dataHead, sizeof(PacketHead), 0, sizeof(PacketHead));
179 int32_t ret = TransProxyProcessSessionData(nullptr, &dataHead, data);
180 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
181
182 ProxyDataInfo *dataInfo = static_cast<ProxyDataInfo *>(SoftBusCalloc(sizeof(ProxyDataInfo)));
183 EXPECT_NE(nullptr, dataInfo);
184 ret = TransProxyProcessSessionData(dataInfo, nullptr, data);
185 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
186
187 ret = TransProxyProcessSessionData(dataInfo, &dataHead, nullptr);
188 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
189
190 TransProxyClearProcessor(nullptr);
191 SliceProcessor *processor = static_cast<SliceProcessor *>(SoftBusCalloc(sizeof(SliceProcessor)));
192 EXPECT_NE(nullptr, processor);
193 processor->data = static_cast<char *>(SoftBusCalloc(sizeof(char)));
194 EXPECT_NE(nullptr, processor->data);
195 TransProxyClearProcessor(processor);
196 SoftBusFree(dataInfo);
197 SoftBusFree(processor->data);
198 SoftBusFree(processor);
199 }
200
201 /**
202 * @tc.name: TransProcessDataTest006
203 * @tc.desc: Transmission session manager initialize.
204 * @tc.type: FUNC
205 * @tc.require:
206 */
207 HWTEST_F(TransProcessDataTest, TransProcessDataTest006, TestSize.Level1)
208 {
209 int32_t seq = 1;
210 ProxyDataInfo *dataInfo = static_cast<ProxyDataInfo *>(SoftBusCalloc(sizeof(ProxyDataInfo)));
211 EXPECT_NE(nullptr, dataInfo);
212
213 const char *sessionKey = "1111"; // test value
214 int32_t ret = TransProxyDecryptPacketData(seq, nullptr, sessionKey);
215 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
216
217 ret = TransProxyDecryptPacketData(seq, dataInfo, nullptr);
218 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
219
220 ret = TransProxyDecryptPacketData(seq, dataInfo, sessionKey);
221 EXPECT_EQ(SOFTBUS_DECRYPT_ERR, ret);
222 SoftBusFree(dataInfo);
223 }
224
225 /**
226 * @tc.name: TransProcessDataTest007
227 * @tc.desc: Transmission session manager initialize.
228 * @tc.type: FUNC
229 * @tc.require:
230 */
231 HWTEST_F(TransProcessDataTest, TransProcessDataTest007, TestSize.Level1)
232 {
233 SliceProcessor *processor = static_cast<SliceProcessor *>(SoftBusCalloc(sizeof(SliceProcessor)));
234 EXPECT_NE(nullptr, processor);
235 SliceHead *head = static_cast<SliceHead *>(SoftBusCalloc(sizeof(SliceHead)));
236 EXPECT_NE(nullptr, head);
237
238 const char *data = "121212"; // test value
239 uint32_t len = 1;
240 bool supportTlv = true;
241 int32_t ret = TransProxyFirstSliceProcess(nullptr, head, data, len, supportTlv);
242 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
243
244 ret = TransProxyFirstSliceProcess(processor, nullptr, data, len, supportTlv);
245 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
246
247 ret = TransProxyFirstSliceProcess(processor, head, nullptr, len, supportTlv);
248 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
249
250 head->priority = PROXY_CHANNEL_PRORITY_MESSAGE;
251 head->sliceNum = -1; // test value
252 ret = TransProxyFirstSliceProcess(processor, head, data, len, supportTlv);
253 EXPECT_EQ(SOFTBUS_INVALID_DATA_HEAD, ret);
254
255 head->sliceNum = 1;
256 ret = TransProxyFirstSliceProcess(processor, head, data, len, supportTlv);
257 EXPECT_EQ(SOFTBUS_OK, ret);
258
259 supportTlv = false;
260 ret = TransProxyFirstSliceProcess(processor, head, data, len, supportTlv);
261 EXPECT_EQ(SOFTBUS_OK, ret);
262 SoftBusFree(processor);
263 SoftBusFree(head);
264 }
265
266 /**
267 * @tc.name: TransProcessDataTest008
268 * @tc.desc: Transmission session manager initialize.
269 * @tc.type: FUNC
270 * @tc.require:
271 */
272 HWTEST_F(TransProcessDataTest, TransProcessDataTest008, TestSize.Level1)
273 {
274 SliceProcessor *processor = static_cast<SliceProcessor *>(SoftBusCalloc(sizeof(SliceProcessor)));
275 EXPECT_NE(nullptr, processor);
276 SliceHead *head = static_cast<SliceHead *>(SoftBusCalloc(sizeof(SliceHead)));
277 EXPECT_NE(nullptr, head);
278
279 const char *data = "121212";
280 uint32_t len = 1;
281 int32_t ret = TransProxySliceProcessChkPkgIsValid(nullptr, head, data, len);
282 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
283
284 ret = TransProxySliceProcessChkPkgIsValid(processor, nullptr, data, len);
285 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
286
287 head->sliceNum = 1;
288 processor->sliceNumber = 1;
289 head->sliceSeq = 1;
290 processor->expectedSeq = 1;
291 processor->dataLen = 5; // test value
292 processor->bufLen = 10; // test value
293 processor->data = static_cast<char *>(SoftBusCalloc(sizeof(char)));
294 EXPECT_NE(nullptr, processor->data);
295
296 ret = TransProxySliceProcessChkPkgIsValid(processor, head, data, len);
297 EXPECT_EQ(SOFTBUS_OK, ret);
298
299 SoftBusFree(processor->data);
300 SoftBusFree(processor);
301 SoftBusFree(head);
302 }
303
304 /**
305 * @tc.name: TransProcessDataTest009
306 * @tc.desc: Transmission session manager initialize.
307 * @tc.type: FUNC
308 * @tc.require:
309 */
310 HWTEST_F(TransProcessDataTest, TransProcessDataTest009, TestSize.Level1)
311 {
312 uint32_t len = 1;
313 int32_t ret = TransGetActualDataLen(nullptr, nullptr);
314 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
315
316 ret = TransProxyNormalSliceProcess(nullptr, nullptr, nullptr, len);
317 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
318
319 SliceProcessor *processor = static_cast<SliceProcessor *>(SoftBusCalloc(sizeof(SliceProcessor)));
320 EXPECT_NE(nullptr, processor);
321 SliceHead *head = static_cast<SliceHead *>(SoftBusCalloc(sizeof(SliceHead)));
322 EXPECT_NE(nullptr, head);
323
324 const char *data = "121212";
325 head->sliceNum = 1;
326 processor->sliceNumber = 1;
327 head->sliceSeq = 1;
328 processor->expectedSeq = 1;
329 processor->dataLen = 5; // test value
330 processor->bufLen = 10; // test value
331 processor->data = static_cast<char *>(SoftBusCalloc(sizeof(char)));
332 EXPECT_NE(nullptr, processor->data);
333
334 TransProxyNormalSliceProcess(processor, head, data, len);
335 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
336
337 SoftBusFree(processor->data);
338 SoftBusFree(processor);
339 SoftBusFree(head);
340 }
341
342 /**
343 * @tc.name: TransProcessDataTest010
344 * @tc.desc: Transmission session manager initialize.
345 * @tc.type: FUNC
346 * @tc.require:
347 */
348 HWTEST_F(TransProcessDataTest, TransProcessDataTest010, TestSize.Level1)
349 {
350 int32_t channelId = TEST_CHANNEL_ID;
351 const char *data = "121212"; // test value
352 uint32_t len = 1;
353 uint32_t newPktHeadSize = 1;
354
355 int32_t ret = TransProxyNoSubPacketTlvProc(channelId, data, len, nullptr, newPktHeadSize);
356 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
357 }
358
359 /**
360 * @tc.name: TransProcessDataTest011
361 * @tc.desc: Transmission session manager initialize.
362 * @tc.type: FUNC
363 * @tc.require:
364 */
365 HWTEST_F(TransProcessDataTest, TransProcessDataTest011, TestSize.Level1)
366 {
367 int32_t channelId = TEST_CHANNEL_ID;
368 uint32_t dataLen = 1;
369 int32_t pkgHeadSize = 1;
370
371 DataBuf *node = static_cast<DataBuf *>(SoftBusCalloc(sizeof(DataBuf)));
372 EXPECT_NE(nullptr, node);
373 node->data = static_cast<char *>(SoftBusCalloc(sizeof(char)));
374 EXPECT_NE(nullptr, node->data);
375 node->w = static_cast<char *>(SoftBusCalloc(sizeof(char)));
376 EXPECT_NE(nullptr, node->w);
377
378 int32_t ret = MoveNode(channelId, nullptr, dataLen, pkgHeadSize);
379 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
380
381 ret = MoveNode(channelId, node, dataLen, pkgHeadSize);
382 EXPECT_EQ(SOFTBUS_MEM_ERR, ret);
383
384 SoftBusFree(node->w);
385 SoftBusFree(node->data);
386 SoftBusFree(node);
387 }
388
389 /**
390 * @tc.name: TransProcessDataTest012
391 * @tc.desc: Transmission session manager initialize.
392 * @tc.type: FUNC
393 * @tc.require:
394 */
395 HWTEST_F(TransProcessDataTest, TransProcessDataTest012, TestSize.Level1)
396 {
397 int32_t channelId = TEST_CHANNEL_ID;
398 int32_t fd = 0;
399 size_t len = 1;
400
401 int32_t ret = TransTdcRecvFirstData(channelId, nullptr, nullptr, fd, len);
402 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
403
404 char *recvBuf = static_cast<char *>(SoftBusCalloc(len));
405 ASSERT_NE(nullptr, recvBuf);
406 int32_t recvLen = 0;
407 ret = TransTdcRecvFirstData(channelId, recvBuf, nullptr, fd, len);
408 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
409
410 ret = TransTdcRecvFirstData(channelId, recvBuf, &recvLen, fd, len);
411 EXPECT_EQ(SOFTBUS_TRANS_INVALID_DATA_LENGTH, ret);
412
413 ret = TransTdcRecvFirstData(channelId, nullptr, &recvLen, fd, len);
414 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
415 SoftBusFree(recvBuf);
416 }
417
418 /**
419 * @tc.name: TransProcessDataTest013
420 * @tc.desc: Transmission session manager initialize.
421 * @tc.type: FUNC
422 * @tc.require:
423 */
424 HWTEST_F(TransProcessDataTest, TransProcessDataTest013, TestSize.Level1)
425 {
426 bool supportTlv = true;
427 int32_t fd = 0;
428 uint32_t len = 1;
429 int32_t ret = TransTdcSendData(nullptr, supportTlv, fd, len, nullptr);
430 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
431
432 DataLenInfo *lenInfo = static_cast<DataLenInfo *>(SoftBusCalloc(sizeof(DataLenInfo)));
433 ASSERT_NE(nullptr, lenInfo);
434 ret = TransTdcSendData(lenInfo, supportTlv, fd, len, nullptr);
435 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
436 lenInfo->outLen = 1;
437 char buf[64] = "1212"; // test value
438 ret = TransTdcSendData(lenInfo, supportTlv, fd, len, buf);
439 EXPECT_EQ(SOFTBUS_ENCRYPT_ERR, ret);
440
441 lenInfo->outLen = 29; // test value
442 ret = TransTdcSendData(lenInfo, supportTlv, fd, len, buf);
443 EXPECT_NE(SOFTBUS_OK, ret);
444 SoftBusFree(lenInfo);
445 }
446
447 /**
448 * @tc.name: TransProcessDataTest014
449 * @tc.desc: Transmission session manager initialize.
450 * @tc.type: FUNC
451 * @tc.require:
452 */
453 HWTEST_F(TransProcessDataTest, TransProcessDataTest014, TestSize.Level1)
454 {
455 int32_t flag = FLAG_ACK;
456 EXPECT_EQ(nullptr, TransTdcPackAllData(nullptr, nullptr, nullptr, flag, nullptr));
457
458 TransTdcPackDataInfo *info = static_cast<TransTdcPackDataInfo *>(SoftBusCalloc(sizeof(TransTdcPackDataInfo)));
459 EXPECT_NE(nullptr, info);
460 info->len = 1;
461 info->seq = 1;
462 info->supportTlv = true;
463 const char *sessionKey = "121212"; // test value
464 const char *data = "1111"; // test value
465 DataLenInfo *lenInfo = static_cast<DataLenInfo *>(SoftBusCalloc(sizeof(DataLenInfo)));
466 EXPECT_NE(nullptr, lenInfo);
467 EXPECT_NE(nullptr, TransTdcPackAllData(info, sessionKey, data, flag, lenInfo));
468
469 int32_t finalSeq = 1;
470 int32_t flags = 1;
471 uint32_t dataLen = 1;
472 int32_t ret = BuildDataHead(nullptr, finalSeq, flags, dataLen, nullptr);
473 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
474
475 SoftBusFree(info);
476 SoftBusFree(lenInfo);
477 }
478
479 /**
480 * @tc.name: TransProcessDataTest015
481 * @tc.desc: Transmission session manager initialize.
482 * @tc.type: FUNC
483 * @tc.require:
484 */
485 HWTEST_F(TransProcessDataTest, TransProcessDataTest015, TestSize.Level1)
486 {
487 int32_t channelId = TEST_CHANNEL_ID;
488 int32_t ret = TransTdcUnPackAllTlvData(channelId, nullptr, nullptr, nullptr, nullptr);
489 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
490
491 uint32_t bufLen = 0;
492 uint32_t headSize = 1;
493 ret = CheckBufLenAndCopyData(bufLen, headSize, nullptr, nullptr);
494 EXPECT_EQ(SOFTBUS_DATA_NOT_ENOUGH, ret);
495
496 ret = TransTdcUnPackData(channelId, nullptr, nullptr, nullptr, nullptr);
497 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
498 }
499
500 /**
501 * @tc.name: TransProcessDataTest016
502 * @tc.desc: Transmission session manager initialize.
503 * @tc.type: FUNC
504 * @tc.require:
505 */
506 HWTEST_F(TransProcessDataTest, TransProcessDataTest016, TestSize.Level1)
507 {
508 int32_t channelId = 1124; // test value
509 const char *sessionKey = "121212"; // test value
510 char plain[10] = "testPlain";
511 uint32_t plainLen = 10; // test value
512 DataBuf *node = static_cast<DataBuf *>(SoftBusCalloc(sizeof(DataBuf)));
513 ASSERT_NE(nullptr, node);
514 node->data = static_cast<char *>(SoftBusCalloc(sizeof(char) * plainLen));
515 if (node->data == nullptr) {
516 SoftBusFree(node);
517 return;
518 }
519
520 node->w = static_cast<char *>(SoftBusCalloc(sizeof(char) * plainLen));
521 if (node->w == nullptr) {
522 SoftBusFree(node->data);
523 SoftBusFree(node);
524 return;
525 }
526
527 node->channelId = channelId;
528 node->size = 10; // test value
529 node->fd = 1;
530 (void)strcpy_s(node->data, 10, plain); // test value
531 (void)strcpy_s(node->w, 10, plain); // test value
532
533 int32_t ret = TransTdcUnPackData(channelId, nullptr, plain, &plainLen, node);
534 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
535 ret = TransTdcUnPackData(channelId, sessionKey, nullptr, &plainLen, node);
536 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
537 ret = TransTdcUnPackData(channelId, sessionKey, plain, nullptr, node);
538 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
539 ret = TransTdcUnPackData(channelId, sessionKey, plain, &plainLen, nullptr);
540 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
541 SoftBusFree(node->w);
542 SoftBusFree(node->data);
543 SoftBusFree(node);
544 }
545
546 /**
547 * @tc.name: TransProcessDataTest017
548 * @tc.desc: Transmission session manager initialize.
549 * @tc.type: FUNC
550 * @tc.require:
551 */
552 HWTEST_F(TransProcessDataTest, TransProcessDataTest017, TestSize.Level1)
553 {
554 char data[] = "testDataStringValue";
555 uint32_t bufLen = strlen(data);
556 TcpDataTlvPacketHead *head = static_cast<TcpDataTlvPacketHead *>(SoftBusCalloc(sizeof(TcpDataTlvPacketHead)));
557 ASSERT_NE(nullptr, head);
558 uint32_t headSize = 4; // test value
559
560 int32_t ret = TransTdcParseTlv(bufLen, data, head, &headSize);
561 EXPECT_EQ(SOFTBUS_DATA_NOT_ENOUGH, ret);
562 SoftBusFree(head);
563 }
564
565 /**
566 * @tc.name: TransProcessDataTest018
567 * @tc.desc: Transmission session manager initialize.
568 * @tc.type: FUNC
569 * @tc.require:
570 */
571 HWTEST_F(TransProcessDataTest, TransProcessDataTest018, TestSize.Level1)
572 {
573 int32_t channelId = 1124; // test value
574 uint32_t headSize = 1;
575 bool flag = true;
576
577 TcpDataTlvPacketHead head;
578 DataBuf node; // test value
579
580 int32_t ret = TransTdcUnPackAllTlvData(channelId, nullptr, &headSize, &node, &flag);
581 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
582 ret = TransTdcUnPackAllTlvData(channelId, &head, nullptr, &node, &flag);
583 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
584 ret = TransTdcUnPackAllTlvData(channelId, &head, &headSize, nullptr, &flag);
585 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
586 ret = TransTdcUnPackAllTlvData(channelId, &head, &headSize, &node, nullptr);
587 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
588 ret = TransTdcUnPackAllTlvData(channelId, &head, nullptr, nullptr, nullptr);
589 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
590 ret = TransTdcUnPackAllTlvData(channelId, nullptr, &headSize, nullptr, nullptr);
591 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
592 ret = TransTdcUnPackAllTlvData(channelId, nullptr, nullptr, &node, nullptr);
593 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
594 ret = TransTdcUnPackAllTlvData(channelId, nullptr, nullptr, nullptr, &flag);
595 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
596 }
597
598 /**
599 * @tc.name: TransProcessDataTest019
600 * @tc.desc: test trans tdc unpack data.
601 * @tc.type: FUNC
602 * @tc.require:
603 */
604 HWTEST_F(TransProcessDataTest, TransProcessDataTest019, TestSize.Level1)
605 {
606 int32_t channelId = 1124; // test value
607 char plain[10] = "testPlain";
608 uint32_t plainLen = 10; // test value
609 DataBuf *node = static_cast<DataBuf *>(SoftBusCalloc(sizeof(DataBuf)));
610 ASSERT_NE(nullptr, node);
611 node->data = static_cast<char *>(SoftBusCalloc(sizeof(char) * plainLen));
612 if (node->data == nullptr) {
613 SoftBusFree(node);
614 return;
615 }
616
617 node->w = static_cast<char *>(SoftBusCalloc(sizeof(char) * plainLen));
618 if (node->w == nullptr) {
619 SoftBusFree(node->data);
620 SoftBusFree(node);
621 return;
622 }
623
624 node->channelId = channelId;
625 node->size = 10; // test value
626 node->fd = 1;
627 (void)strcpy_s(node->data, 10, plain); // test value
628 (void)strcpy_s(node->w, 10, plain); // test value
629
630 int32_t ret = TransTdcUnPackAllData(channelId, nullptr, nullptr);
631 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
632
633 ret = TransTdcUnPackAllData(channelId, node, nullptr);
634 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
635
636 bool flag = true;
637 ret = TransTdcUnPackAllData(channelId, nullptr, &flag);
638 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
639
640 ret = TransTdcUnPackAllData(channelId, node, &flag);
641 EXPECT_EQ(SOFTBUS_INVALID_DATA_HEAD, ret);
642 SoftBusFree(node->w);
643 SoftBusFree(node->data);
644 SoftBusFree(node);
645 }
646
647 /**
648 * @tc.name: TransProxyPackD2DDataTest001
649 * @tc.desc: test trans proxy pack d2d data.
650 * @tc.type: FUNC
651 * @tc.require:
652 */
653 HWTEST_F(TransProcessDataTest, TransProxyPackD2DDataTest001, TestSize.Level1)
654 {
655 uint32_t sliceNum = 0;
656 SessionPktType pktType = TRANS_SESSION_BYTES;
657 uint32_t cnt = 0;
658 uint32_t dataLen = 0;
659 ProxyDataInfo dataInfo;
660 uint8_t *ret = TransProxyPackD2DData(nullptr, sliceNum, pktType, cnt, &dataLen);
661 EXPECT_EQ(NULL, ret);
662
663 ret = TransProxyPackD2DData(&dataInfo, sliceNum, pktType, cnt, &dataLen);
664 EXPECT_EQ(nullptr, ret);
665
666 sliceNum = 1;
667 ret = TransProxyPackD2DData(&dataInfo, sliceNum, pktType, cnt, nullptr);
668 EXPECT_EQ(nullptr, ret);
669
670 ret = TransProxyPackD2DData(&dataInfo, sliceNum, pktType, cnt, &dataLen);
671 EXPECT_EQ(nullptr, ret);
672
673 sliceNum = 2;
674 ret = TransProxyPackD2DData(&dataInfo, sliceNum, pktType, cnt, &dataLen);
675 EXPECT_EQ(nullptr, ret);
676 }
677
678 /**
679 * @tc.name: TransProxyProcessD2DDataTest001
680 * @tc.desc: test trans proxy process d2d data.
681 * @tc.type: FUNC
682 * @tc.require:
683 */
684 HWTEST_F(TransProcessDataTest, TransProxyProcessD2DDataTest001, TestSize.Level1)
685 {
686 ProxyDataInfo dataInfo;
687 PacketD2DHead dataHead;
688 int32_t businessType = 0;
689 char data[] = "11111";
690 int32_t ret = TransProxyProcessD2DData(nullptr, &dataHead, data, businessType);
691 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
692
693 ret = TransProxyProcessD2DData(&dataInfo, nullptr, data, businessType);
694 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
695
696 ret = TransProxyProcessD2DData(&dataInfo, &dataHead, nullptr, businessType);
697 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
698 dataHead.dataLen = 0;
699 businessType = BUSINESS_TYPE_D2D_VOICE;
700 ret = TransProxyProcessD2DData(&dataInfo, &dataHead, data, businessType);
701 EXPECT_EQ(SOFTBUS_TRANS_INVALID_DATA_LENGTH, ret);
702
703 dataHead.dataLen = 8;
704 businessType = BUSINESS_TYPE_D2D_VOICE;
705 ret = TransProxyProcessD2DData(&dataInfo, &dataHead, data, businessType);
706 EXPECT_EQ(SOFTBUS_OK, ret);
707
708 dataHead.dataLen = 10;
709 businessType = BUSINESS_TYPE_D2D_VOICE;
710 ret = TransProxyProcessD2DData(&dataInfo, &dataHead, data, businessType);
711 EXPECT_EQ(SOFTBUS_OK, ret);
712 if (dataInfo.outData != nullptr) {
713 SoftBusFree(dataInfo.outData);
714 }
715 }
716
717 /**
718 * @tc.name: TransProxyDecryptD2DDataTest001
719 * @tc.desc: test trans proxy decrypt d2d data.
720 * @tc.type: FUNC
721 * @tc.require:
722 */
723 HWTEST_F(TransProcessDataTest, TransProxyDecryptD2DDataTest001, TestSize.Level1)
724 {
725 ProxyDataInfo dataInfo;
726 int32_t businessType = 0;
727 char sessionKey[SHORT_SESSION_KEY_LENGTH] = "11111";
728 unsigned char sessionCommonIv[BLE_BROADCAST_IV_LEN] = "111111";
729 int32_t ret = TransProxyDecryptD2DData(businessType, nullptr, sessionKey, sessionCommonIv);
730 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
731
732 ret = TransProxyDecryptD2DData(businessType, &dataInfo, nullptr, sessionCommonIv);
733 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
734
735 ret = TransProxyDecryptD2DData(businessType, &dataInfo, sessionKey, sessionCommonIv);
736 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
737
738 ret = TransProxyDecryptD2DData(businessType, &dataInfo, sessionKey, nullptr);
739 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
740
741 businessType = BUSINESS_TYPE_D2D_VOICE;
742 dataInfo.inData = (uint8_t *)"11111";
743 dataInfo.inLen = 6;
744 ret = TransProxyDecryptD2DData(businessType, &dataInfo, sessionKey, sessionCommonIv);
745 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
746
747 businessType = BUSINESS_TYPE_D2D_MESSAGE;
748 ret = TransProxyDecryptD2DData(businessType, &dataInfo, sessionKey, sessionCommonIv);
749 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
750
751 businessType = BUSINESS_TYPE_D2D_MESSAGE;
752 dataInfo.inData = (uint8_t *)"11111111111";
753 dataInfo.inLen = 12;
754 ret = TransProxyDecryptD2DData(businessType, &dataInfo, sessionKey, sessionCommonIv);
755 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
756 }
757
758 /**
759 * @tc.name: TransProxyD2DFirstSliceProcessTest001
760 * @tc.desc: test trans proxy d2d first slice process.
761 * @tc.type: FUNC
762 * @tc.require:
763 */
764 HWTEST_F(TransProcessDataTest, TransProxyD2DFirstSliceProcessTest001, TestSize.Level1)
765 {
766 SliceProcessor sliceProcessor;
767 SliceHead head;
768 char data[] = "11111";
769 uint32_t len = 6;
770 int32_t businessType = 0;
771 int32_t ret = TransProxyD2DFirstSliceProcess(nullptr, &head, data, len, businessType);
772 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
773
774 ret = TransProxyD2DFirstSliceProcess(&sliceProcessor, nullptr, data, len, businessType);
775 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
776
777 ret = TransProxyD2DFirstSliceProcess(&sliceProcessor, &head, nullptr, len, businessType);
778 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
779
780 head.priority = PROXY_CHANNEL_PRORITY_BYTES;
781 businessType = BUSINESS_TYPE_D2D_VOICE;
782 ret = TransProxyD2DFirstSliceProcess(&sliceProcessor, &head, data, len, businessType);
783 EXPECT_EQ(SOFTBUS_OK, ret);
784
785 head.priority = PROXY_CHANNEL_PRORITY_MESSAGE;
786 ret = TransProxyD2DFirstSliceProcess(&sliceProcessor, &head, data, len, businessType);
787 EXPECT_EQ(SOFTBUS_OK, ret);
788
789 head.sliceNum = -1;
790 head.priority = PROXY_CHANNEL_PRORITY_MESSAGE;
791 ret = TransProxyD2DFirstSliceProcess(&sliceProcessor, &head, data, len, businessType);
792 EXPECT_EQ(SOFTBUS_INVALID_DATA_HEAD, ret);
793
794 head.sliceNum = 1;
795 head.priority = PROXY_CHANNEL_PRORITY_MESSAGE;
796 ret = TransProxyD2DFirstSliceProcess(&sliceProcessor, &head, data, len, businessType);
797 EXPECT_EQ(SOFTBUS_OK, ret);
798 if (sliceProcessor.data != nullptr) {
799 SoftBusFree(sliceProcessor.data);
800 }
801 }
802
803 /**
804 * @tc.name: TransProxyPackD2DBytesTest001
805 * @tc.desc: test trans proxy pack d2d bytes.
806 * @tc.type: FUNC
807 * @tc.require:
808 */
809 HWTEST_F(TransProcessDataTest, TransProxyPackD2DBytesTest001, TestSize.Level1)
810 {
811 ProxyDataInfo dataInfo;
812 char sessionKey[] = "11111";
813 char sessionIv[] = "11111";
814 SessionPktType flag = TRANS_SESSION_BYTES;
815 int32_t ret = TransProxyPackD2DBytes(nullptr, sessionKey, sessionIv, flag);
816 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
817
818 ret = TransProxyPackD2DBytes(&dataInfo, nullptr, sessionIv, flag);
819 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
820
821 ret = TransProxyPackD2DBytes(&dataInfo, sessionKey, nullptr, flag);
822 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
823
824 ret = TransProxyPackD2DBytes(&dataInfo, sessionKey, sessionIv, flag);
825 EXPECT_EQ(SOFTBUS_TRANS_PROXY_SESS_ENCRYPT_ERR, ret);
826
827 dataInfo.inData = (uint8_t *)"1111";
828 dataInfo.inLen = 4;
829 ret = TransProxyPackD2DBytes(&dataInfo, sessionKey, sessionIv, flag);
830 EXPECT_EQ(SOFTBUS_OK, ret);
831 }
832 }
833