1 /*
2 * Copyright (c) 2022-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 "client_trans_proxy_file_manager.h"
20 #include "client_trans_proxy_manager.c"
21 #include "client_trans_proxy_manager.h"
22 #include "client_trans_session_manager.h"
23 #include "client_trans_socket_manager.h"
24 #include "client_trans_tcp_direct_message.h"
25 #include "session.h"
26 #include "softbus_access_token_test.h"
27 #include "softbus_def.h"
28 #include "softbus_error_code.h"
29 #include "trans_proxy_process_data.c"
30 #include "trans_proxy_process_data.h"
31
32 #define TEST_CHANNEL_ID (-10)
33 #define TEST_ERR_CODE (-1)
34 #define TEST_DATA "testdata"
35 #define TEST_DATA_LENGTH 9
36 #define TEST_DATA_LENGTH_2 100
37 #define TEST_FILE_CNT 4
38 #define TEST_SEQ 188
39 #define SILCE_NUM_COUNT 3
40 #define SLICE_SEQ_BEGIN 0
41 #define SLICE_SEQ_MID 1
42 #define SLICE_SEQ_END 2
43
44 using namespace std;
45 using namespace testing::ext;
46
47 namespace OHOS {
48 const char *g_proxyPkgName = "dms";
49 const char *g_proxySessionName = "ohos.distributedschedule.dms.test";
50 const char *g_testProxyFileName[] = {
51 "/data/test.txt",
52 "/data/ss.txt",
53 "/data/test.tar",
54 "/data/test.mp3",
55 };
56 const char *g_proxyFileSet[] = {
57 "/data/data/test.txt",
58 "/path/max/length/512/"
59 "11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
60 "11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
61 "11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
62 "11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
63 "111111111111111111111111111111111111111111111111111",
64 "ss",
65 "/data/ss",
66 };
67 char g_sessionKey[32] = "1234567812345678123456781234567";
68 #define DEFAULT_NEW_BYTES_LEN (4 * 1024 * 1024)
69 #define DEFAULT_NEW_MESSAGE_LEN (4 * 1024)
70
TransOnSessionOpened(const char * sessionName,const ChannelInfo * channel,SessionType flag,SocketAccessInfo * accessInfo)71 int32_t TransOnSessionOpened(
72 const char *sessionName, const ChannelInfo *channel, SessionType flag, SocketAccessInfo *accessInfo)
73 {
74 return SOFTBUS_OK;
75 }
76
TransOnSessionClosed(int32_t channelId,int32_t channelType,ShutdownReason reason)77 int32_t TransOnSessionClosed(int32_t channelId, int32_t channelType, ShutdownReason reason)
78 {
79 return SOFTBUS_OK;
80 }
81
TransOnSessionOpenFailed(int32_t channelId,int32_t channelType,int32_t errCode)82 int32_t TransOnSessionOpenFailed(int32_t channelId, int32_t channelType, int32_t errCode)
83 {
84 return SOFTBUS_OK;
85 }
86
TransOnBytesReceived(int32_t channelId,int32_t channelType,const void * data,uint32_t len,SessionPktType type)87 int32_t TransOnBytesReceived(int32_t channelId, int32_t channelType,
88 const void *data, uint32_t len, SessionPktType type)
89 {
90 return SOFTBUS_OK;
91 }
92
TransOnOnStreamRecevied(int32_t channelId,int32_t channelType,const StreamData * data,const StreamData * ext,const StreamFrameInfo * param)93 int32_t TransOnOnStreamRecevied(int32_t channelId, int32_t channelType,
94 const StreamData *data, const StreamData *ext, const StreamFrameInfo *param)
95 {
96 return SOFTBUS_OK;
97 }
98
TransOnGetSessionId(int32_t channelId,int32_t channelType,int32_t * sessionId)99 int32_t TransOnGetSessionId(int32_t channelId, int32_t channelType, int32_t *sessionId)
100 {
101 return SOFTBUS_OK;
102 }
TransOnQosEvent(int32_t channelId,int32_t channelType,int32_t eventId,int32_t tvCount,const QosTv * tvList)103 int32_t TransOnQosEvent(int32_t channelId, int32_t channelType, int32_t eventId,
104 int32_t tvCount, const QosTv *tvList)
105 {
106 return SOFTBUS_OK;
107 }
108
109 static IClientSessionCallBack g_clientSessionCb = {
110 .OnSessionOpened = TransOnSessionOpened,
111 .OnSessionClosed = TransOnSessionClosed,
112 .OnSessionOpenFailed = TransOnSessionOpenFailed,
113 .OnDataReceived = TransOnBytesReceived,
114 .OnStreamReceived = TransOnOnStreamRecevied,
115 .OnQosEvent = TransOnQosEvent,
116 };
117
OnSessionOpened(const char * sessionName,const ChannelInfo * channel,SessionType flag,SocketAccessInfo * accessInfo)118 int32_t OnSessionOpened(
119 const char *sessionName, const ChannelInfo *channel, SessionType flag, SocketAccessInfo *accessInfo)
120 {
121 (void)sessionName;
122 (void)channel;
123 (void)flag;
124 (void)accessInfo;
125 return SOFTBUS_INVALID_PARAM;
126 }
127
OnSessionClosed(int32_t channelId,int32_t channelType,ShutdownReason reason)128 int32_t OnSessionClosed(int32_t channelId, int32_t channelType, ShutdownReason reason)
129 {
130 (void)channelId;
131 (void)channelType;
132 (void)reason;
133 return SOFTBUS_INVALID_PARAM;
134 }
135
OnSessionOpenFailed(int32_t channelId,int32_t channelType,int32_t errCode)136 int32_t OnSessionOpenFailed(int32_t channelId, int32_t channelType, int32_t errCode)
137 {
138 (void)channelId;
139 (void)channelType;
140 (void)errCode;
141 return SOFTBUS_INVALID_PARAM;
142 }
143
OnBytesReceived(int32_t channelId,int32_t channelType,const void * data,uint32_t len,SessionPktType type)144 int32_t OnBytesReceived(int32_t channelId, int32_t channelType,
145 const void *data, uint32_t len, SessionPktType type)
146 {
147 (void)channelId;
148 (void)channelType;
149 (void)data;
150 (void)len;
151 (void)type;
152 return SOFTBUS_INVALID_PARAM;
153 }
154
155 static IClientSessionCallBack g_sessionCb = {
156 .OnSessionOpened = OnSessionOpened,
157 .OnSessionClosed = OnSessionClosed,
158 .OnSessionOpenFailed = OnSessionOpenFailed,
159 .OnDataReceived = OnBytesReceived,
160 };
161
162 class ClientTransProxyManagerTest : public testing::Test {
163 public:
ClientTransProxyManagerTest()164 ClientTransProxyManagerTest() {}
~ClientTransProxyManagerTest()165 ~ClientTransProxyManagerTest() {}
166 static void SetUpTestCase(void);
167 static void TearDownTestCase(void);
SetUp()168 void SetUp() override {}
TearDown()169 void TearDown() override {}
170 };
171
SetUpTestCase(void)172 void ClientTransProxyManagerTest::SetUpTestCase(void)
173 {
174 TransClientInit();
175 int32_t ret = ClientTransProxyInit(&g_clientSessionCb);
176 EXPECT_EQ(SOFTBUS_OK, ret);
177 SetAccessTokenPermission("dsoftbusTransTest");
178 }
179
TearDownTestCase(void)180 void ClientTransProxyManagerTest::TearDownTestCase(void)
181 {
182 TransClientDeinit();
183 }
184
185 /**
186 * @tc.name: ClientTransProxyInitTest
187 * @tc.desc: client trans proxy init test, use the wrong or normal parameter.
188 * @tc.type: FUNC
189 * @tc.require:
190 */
191 HWTEST_F(ClientTransProxyManagerTest, ClientTransProxyInitTest, TestSize.Level1)
192 {
193 int32_t ret = ClientTransProxyInit(nullptr);
194 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
195 }
196
197 /**
198 * @tc.name: ClientTransProxyOnChannelOpenedTest
199 * @tc.desc: client trans proxy on channel opened test, use the wrong or normal parameter.
200 * @tc.type: FUNC
201 * @tc.require:
202 */
203 HWTEST_F(ClientTransProxyManagerTest, ClientTransProxyOnChannelOpenedTest, TestSize.Level1)
204 {
205 int32_t ret = ClientTransProxyOnChannelOpened(g_proxySessionName, nullptr, nullptr);
206 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
207
208 ChannelInfo channelInfo = {0};
209 ret = ClientTransProxyOnChannelOpened(g_proxySessionName, &channelInfo, nullptr);
210 EXPECT_EQ(SOFTBUS_MEM_ERR, ret);
211 }
212
213 /**
214 * @tc.name: ClientTransProxyOnDataReceivedTest
215 * @tc.desc: client trans proxy on data received test, use the wrong or normal parameter.
216 * @tc.type: FUNC
217 * @tc.require:
218 */
219 HWTEST_F(ClientTransProxyManagerTest, ClientTransProxyOnDataReceivedTest, TestSize.Level1)
220 {
221 int32_t channelId = 1;
222 int32_t ret = ClientTransProxyOnDataReceived(channelId, nullptr, TEST_DATA_LENGTH, TRANS_SESSION_BYTES);
223 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
224
225 ret = ClientTransProxyOnDataReceived(channelId, TEST_DATA, TEST_DATA_LENGTH, TRANS_SESSION_BYTES);
226 EXPECT_EQ(SOFTBUS_TRANS_PROXY_INVALID_CHANNEL_ID, ret);
227 }
228
229 /**
230 * @tc.name: ClientTransProxyOnDataReceivedTest001
231 * @tc.desc: client trans proxy on data received test. test wrong slice head or packet head
232 * @tc.type: FUNC
233 * @tc.require:
234 */
235 HWTEST_F(ClientTransProxyManagerTest, ClientTransProxyOnDataReceivedTest001, TestSize.Level1)
236 {
237 int32_t channelId = 1;
238 ChannelInfo channelInfo;
239 channelInfo.channelId = channelId;
240 channelInfo.sessionKey = g_sessionKey;
241 channelInfo.isEncrypt = true;
242 channelInfo.isSupportTlv = true;
243 int32_t ret = ClientTransProxyOnChannelOpened(g_proxySessionName, &channelInfo, nullptr);
244 EXPECT_EQ(SOFTBUS_OK, ret);
245 ret = ClientTransProxyOnDataReceived(channelId, TEST_DATA, TEST_DATA_LENGTH, TRANS_SESSION_BYTES);
246 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
247
248 SliceHead sliceHead;
249 sliceHead.priority = PROXY_CHANNEL_PRORITY_BUTT;
250 char buf[TEST_DATA_LENGTH_2];
251 ret = memcpy_s(buf, TEST_DATA_LENGTH_2, &sliceHead, sizeof(SliceHead));
252 EXPECT_EQ(EOK, ret);
253 PacketHead packetHead;
254 ret = memcpy_s(buf + sizeof(SliceHead), TEST_DATA_LENGTH_2, &packetHead, sizeof(PacketHead));
255 EXPECT_EQ(EOK, ret);
256 ret = ClientTransProxyOnDataReceived(channelId, buf, TEST_DATA_LENGTH_2, TRANS_SESSION_BYTES);
257 EXPECT_EQ(SOFTBUS_TRANS_PROXY_INVALID_SLICE_HEAD, ret);
258
259 sliceHead.priority = PROXY_CHANNEL_PRORITY_MESSAGE;
260 sliceHead.sliceNum = 0;
261 sliceHead.sliceSeq = 0;
262 ret = memcpy_s(buf, TEST_DATA_LENGTH_2, &sliceHead, sizeof(SliceHead));
263 EXPECT_EQ(EOK, ret);
264 ret = ClientTransProxyOnDataReceived(channelId, buf, TEST_DATA_LENGTH_2, TRANS_SESSION_BYTES);
265 EXPECT_EQ(SOFTBUS_TRANS_PROXY_INVALID_SLICE_HEAD, ret);
266
267 sliceHead.priority = PROXY_CHANNEL_PRORITY_MESSAGE;
268 sliceHead.sliceNum = 1;
269 ret = memcpy_s(buf, TEST_DATA_LENGTH_2, &sliceHead, sizeof(SliceHead));
270 EXPECT_EQ(EOK, ret);
271 packetHead.magicNumber = 1;
272 ret = memcpy_s(buf + sizeof(SliceHead), TEST_DATA_LENGTH_2, &packetHead, sizeof(PacketHead));
273 EXPECT_EQ(EOK, ret);
274 ret = ClientTransProxyOnDataReceived(channelId, buf, TEST_DATA_LENGTH_2, TRANS_SESSION_BYTES);
275 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
276
277 packetHead.magicNumber = MAGIC_NUMBER;
278 packetHead.dataLen = 0;
279 ret = memcpy_s(buf + sizeof(SliceHead), TEST_DATA_LENGTH_2, &packetHead, sizeof(PacketHead));
280 EXPECT_EQ(EOK, ret);
281 ret = ClientTransProxyOnDataReceived(channelId, buf, TEST_DATA_LENGTH_2, TRANS_SESSION_BYTES);
282 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
283
284 packetHead.dataLen = sizeof(PacketHead) - 1;
285 ret = memcpy_s(buf + sizeof(SliceHead), TEST_DATA_LENGTH_2, &packetHead, sizeof(PacketHead));
286 EXPECT_EQ(EOK, ret);
287 ret = ClientTransProxyOnDataReceived(channelId, buf, TEST_DATA_LENGTH_2, TRANS_SESSION_BYTES);
288 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
289 }
290
291 /**
292 * @tc.name: ClientTransProxyOnDataReceivedTest002
293 * @tc.desc: client trans proxy on data received test. test wrong slice data
294 * @tc.type: FUNC
295 * @tc.require:
296 */
297 HWTEST_F(ClientTransProxyManagerTest, ClientTransProxyOnDataReceivedTest002, TestSize.Level1)
298 {
299 g_proxyMaxByteBufSize = DEFAULT_NEW_BYTES_LEN;
300 g_proxyMaxMessageBufSize = DEFAULT_NEW_MESSAGE_LEN;
301 int32_t channelId = 1;
302
303 SliceHead sliceHead;
304 sliceHead.priority = PROXY_CHANNEL_PRORITY_MESSAGE;
305 sliceHead.sliceNum = 1;
306 char buf[TEST_DATA_LENGTH_2];
307 int32_t ret = memcpy_s(buf, TEST_DATA_LENGTH_2, &sliceHead, sizeof(SliceHead));
308 EXPECT_EQ(EOK, ret);
309 PacketHead packetHead;
310 packetHead.magicNumber = MAGIC_NUMBER;
311 packetHead.dataLen = TEST_DATA_LENGTH_2 - sizeof(SliceHead) - sizeof(PacketHead);
312 ret = memcpy_s(buf + sizeof(SliceHead), TEST_DATA_LENGTH_2, &packetHead, sizeof(PacketHead));
313 EXPECT_EQ(EOK, ret);
314 ret = ClientTransProxyOnDataReceived(channelId, buf, TEST_DATA_LENGTH_2, TRANS_SESSION_BYTES);
315 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
316
317 sliceHead.sliceNum = SILCE_NUM_COUNT;
318 sliceHead.sliceSeq = SLICE_SEQ_BEGIN;
319 ret = memcpy_s(buf, TEST_DATA_LENGTH_2, &sliceHead, sizeof(SliceHead));
320 EXPECT_EQ(EOK, ret);
321 ret = ClientTransProxyOnDataReceived(channelId, buf, TEST_DATA_LENGTH_2, TRANS_SESSION_BYTES);
322 EXPECT_EQ(SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND, ret);
323
324 sliceHead.priority = PROXY_CHANNEL_PRORITY_BYTES;
325 int32_t dataLen = sizeof(SliceHead) + sizeof(PacketHead) + 1;
326 char buf2[dataLen];
327 ret = memcpy_s(buf2, dataLen, &sliceHead, sizeof(SliceHead));
328 EXPECT_EQ(EOK, ret);
329 ret = memcpy_s(buf2 + sizeof(SliceHead), dataLen, &packetHead, sizeof(PacketHead));
330 EXPECT_EQ(EOK, ret);
331 ret = ClientTransProxyOnDataReceived(channelId, buf2, dataLen, TRANS_SESSION_BYTES);
332 EXPECT_EQ(SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND, ret);
333
334 sliceHead.sliceSeq = SLICE_SEQ_MID;
335 ret = memcpy_s(buf2, dataLen, &sliceHead, sizeof(SliceHead));
336 EXPECT_EQ(EOK, ret);
337 ret = ClientTransProxyOnDataReceived(channelId, buf2, dataLen, TRANS_SESSION_BYTES);
338 EXPECT_EQ(SOFTBUS_TRANS_PROXY_ASSEMBLE_PACK_NO_INVALID, ret);
339
340 sliceHead.sliceSeq = SLICE_SEQ_END;
341 ret = memcpy_s(buf2, dataLen, &sliceHead, sizeof(SliceHead));
342 EXPECT_EQ(EOK, ret);
343 ret = ClientTransProxyOnDataReceived(channelId, buf2, dataLen, TRANS_SESSION_BYTES);
344 EXPECT_EQ(SOFTBUS_TRANS_PROXY_ASSEMBLE_PACK_NO_INVALID, ret);
345
346 ClientTransProxyCloseChannel(channelId);
347 }
348
349 /**
350 * @tc.name: TransProxyChannelSendBytesTest
351 * @tc.desc: client trans proxy end bytes test
352 * @tc.type: FUNC
353 * @tc.require:
354 */
355 HWTEST_F(ClientTransProxyManagerTest, TransProxyChannelSendBytesTest, TestSize.Level1)
356 {
357 int32_t channelId = 1;
358 ChannelInfo channelInfo;
359 channelInfo.channelId = channelId;
360 channelInfo.sessionKey = g_sessionKey;
361 channelInfo.isEncrypt = false;
362 channelInfo.isSupportTlv = true;
363 int32_t ret = ClientTransProxyOnChannelOpened(g_proxySessionName, &channelInfo, nullptr);
364 EXPECT_EQ(SOFTBUS_OK, ret);
365
366 ret = TransProxyChannelSendBytes(channelId, TEST_DATA, TEST_DATA_LENGTH, false);
367 EXPECT_EQ(SOFTBUS_PERMISSION_DENIED, ret);
368 ClientTransProxyCloseChannel(channelId);
369
370 channelInfo.isEncrypt = true;
371 ret = ClientTransProxyOnChannelOpened(g_proxySessionName, &channelInfo, nullptr);
372 EXPECT_EQ(SOFTBUS_OK, ret);
373
374 ret = TransProxyChannelSendBytes(channelId, TEST_DATA, TEST_DATA_LENGTH, false);
375 EXPECT_EQ(SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND, ret);
376 ClientTransProxyCloseChannel(channelId);
377 }
378
379 /**
380 * @tc.name: TransProxyChannelSendMessageTest
381 * @tc.desc: client trans proxy end bytes test
382 * @tc.type: FUNC
383 * @tc.require:
384 */
385 HWTEST_F(ClientTransProxyManagerTest, TransProxyChannelSendMessageTest, TestSize.Level1)
386 {
387 int32_t channelId = 1;
388 ChannelInfo channelInfo;
389 channelInfo.channelId = channelId;
390 channelInfo.sessionKey = g_sessionKey;
391 channelInfo.isEncrypt = false;
392 channelInfo.isSupportTlv = false;
393 int32_t ret = ClientTransProxyOnChannelOpened(g_proxySessionName, &channelInfo, nullptr);
394 EXPECT_EQ(SOFTBUS_OK, ret);
395
396 ret = TransProxyChannelSendMessage(channelId, TEST_DATA, TEST_DATA_LENGTH);
397 EXPECT_EQ(SOFTBUS_PERMISSION_DENIED, ret);
398 ClientTransProxyCloseChannel(channelId);
399
400 channelInfo.isEncrypt = true;
401 ret = ClientTransProxyOnChannelOpened(g_proxySessionName, &channelInfo, nullptr);
402 EXPECT_EQ(SOFTBUS_OK, ret);
403
404 ret = TransProxyChannelSendMessage(channelId, TEST_DATA, TEST_DATA_LENGTH);
405 EXPECT_EQ(SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND, ret);
406 ClientTransProxyCloseChannel(channelId);
407 }
408
409 /**
410 * @tc.name: ClientTransProxyErrorCallBackTest
411 * @tc.desc: client trans proxy error callback test, use the wrong or normal parameter.
412 * @tc.type: FUNC
413 * @tc.require:
414 */
415 HWTEST_F(ClientTransProxyManagerTest, ClientTransProxyErrorCallBackTest, TestSize.Level1)
416 {
417 int32_t channelId = 1;
418 ChannelInfo channelInfo;
419 channelInfo.channelId = channelId;
420 channelInfo.sessionKey = g_sessionKey;
421 channelInfo.isEncrypt = false;
422 channelInfo.isSupportTlv = true;
423 int32_t ret = ClientTransProxyOnChannelOpened(g_proxySessionName, &channelInfo, nullptr);
424 EXPECT_EQ(SOFTBUS_OK, ret);
425
426 ret = ClientTransProxyOnDataReceived(channelId, TEST_DATA, TEST_DATA_LENGTH, TRANS_SESSION_BYTES);
427 EXPECT_EQ(SOFTBUS_OK, ret);
428 ClientTransProxyCloseChannel(channelId);
429
430 ret = ClientTransProxyInit(&g_sessionCb);
431 EXPECT_EQ(SOFTBUS_OK, ret);
432
433 ret = ClientTransProxyOnChannelOpened(g_proxySessionName, &channelInfo, nullptr);
434 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
435
436 ret = ClientTransProxyOnDataReceived(channelId, TEST_DATA, TEST_DATA_LENGTH, TRANS_SESSION_BYTES);
437 EXPECT_NE(SOFTBUS_OK, ret);
438 }
439
440 /**
441 * @tc.name: ClientTransProxyCloseChannelTest
442 * @tc.desc: client trans proxy close channel test, use the normal parameter.
443 * @tc.type: FUNC
444 * @tc.require:
445 */
446 HWTEST_F(ClientTransProxyManagerTest, ClientTransProxyCloseChannelTest, TestSize.Level1)
447 {
448 int32_t ret = ClientTransProxyInit(&g_sessionCb);
449 EXPECT_EQ(SOFTBUS_OK, ret);
450 int32_t channelId = 1;
451 ClientTransProxyCloseChannel(TEST_CHANNEL_ID);
452
453 ClientTransProxyCloseChannel(channelId);
454 }
455
456 /**
457 * @tc.name: TransProxyChannelSendFileTest
458 * @tc.desc: trans proxy channel send file test, use the wrong parameter.
459 * @tc.type: FUNC
460 * @tc.require:
461 */
462 HWTEST_F(ClientTransProxyManagerTest, TransProxyChannelSendFileTest, TestSize.Level1)
463 {
464 int32_t channelId = 1;
465 int32_t ret = TransProxyChannelSendFile(channelId, nullptr, g_proxyFileSet, TEST_FILE_CNT);
466 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
467
468 ret = TransProxyChannelSendFile(channelId, g_testProxyFileName, g_proxyFileSet, MAX_SEND_FILE_NUM + TEST_FILE_CNT);
469 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
470
471 ret = TransProxyChannelSendFile(channelId, g_testProxyFileName, nullptr, TEST_FILE_CNT);
472 EXPECT_EQ(SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND, ret);
473
474 ret = TransProxyChannelSendFile(channelId, g_testProxyFileName, g_proxyFileSet, TEST_FILE_CNT);
475 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
476 }
477
478 /**
479 * @tc.name: ClientTransProxyGetInfoByChannelIdTest
480 * @tc.desc: Should return SOFTBUS_INVALID_PARAM when given channelInfo is null.
481 * @tc.desc: Should return SOFTBUS_TRANS_PROXY_CHANNEL_NOT_FOUND when given invalid parameter.
482 * @tc.type: FUNC
483 * @tc.require:
484 */
485 HWTEST_F(ClientTransProxyManagerTest, ClientTransProxyGetInfoByChannelIdTest, TestSize.Level1)
486 {
487 int32_t channelId = 1;
488 ProxyChannelInfoDetail info;
489 memset_s(&info, sizeof(ProxyChannelInfoDetail), 0, sizeof(ProxyChannelInfoDetail));
490 int32_t ret = ClientTransProxyGetInfoByChannelId(channelId, nullptr);
491 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
492
493 ret = ClientTransProxyGetInfoByChannelId(channelId, &info);
494 EXPECT_EQ(SOFTBUS_TRANS_PROXY_CHANNEL_NOT_FOUND, ret);
495 }
496
497 /**
498 * @tc.name: TransProxyPackAndSendDataTest
499 * @tc.desc: Should return SOFTBUS_INVALID_PARAM when given channelInfo or data is null.
500 * @tc.desc: Should return SOFTBUS_TRANS_PROXY_SEND_REQUEST_FAILED when given invalid parameter.
501 * @tc.type: FUNC
502 * @tc.require:
503 */
504 HWTEST_F(ClientTransProxyManagerTest, TransProxyPackAndSendDataTest, TestSize.Level1)
505 {
506 int32_t channelId = 1;
507 const char *data = "test";
508 uint32_t len = 5;
509 ProxyChannelInfoDetail info;
510 memset_s(&info, sizeof(ProxyChannelInfoDetail), 0, sizeof(ProxyChannelInfoDetail));
511 SessionPktType pktType = TRANS_SESSION_MESSAGE;
512 int32_t ret = ClientTransProxyPackAndSendData(channelId, nullptr, len, &info, pktType);
513 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
514 ret = ClientTransProxyPackAndSendData(channelId, data, len, nullptr, pktType);
515 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
516 ret = ClientTransProxyPackAndSendData(channelId,
517 static_cast<const void *>(data), len, &info, pktType);
518 EXPECT_EQ(SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND, ret);
519 }
520
521 /**
522 * @tc.name: ClientTransProxyGetLinkTypeByChannelId
523 * @tc.desc: Should return SOFTBUS_INVALID_PARAM when given linkType or data is null.
524 * @tc.desc: Should return SOFTBUS_NOT_FIND when get link type failed.
525 * @tc.type: FUNC
526 * @tc.require:
527 */
528 HWTEST_F(ClientTransProxyManagerTest, ClientTransProxyGetLinkTypeByChannelIdTest, TestSize.Level1)
529 {
530 int32_t channelId = -1;
531 int32_t ret = ClientTransProxyGetLinkTypeByChannelId(channelId, nullptr);
532 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
533 int32_t linkType;
534 ret = ClientTransProxyGetLinkTypeByChannelId(channelId, &linkType);
535 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
536 }
537
538 /**
539 * @tc.name: TransGetActualDataLen
540 * @tc.desc: TransGetActualDataLen test.
541 * @tc.type: FUNC
542 * @tc.require:
543 */
544 HWTEST_F(ClientTransProxyManagerTest, TransGetActualDataLenTest, TestSize.Level1)
545 {
546 SliceHead head = {};
547 uint32_t actualDataLen = 0;
548 g_proxyMaxByteBufSize = DEFAULT_NEW_BYTES_LEN;
549 g_proxyMaxMessageBufSize = DEFAULT_NEW_MESSAGE_LEN;
550
551 // Test case 1: Valid sliceNum, priority message
552 head.sliceNum = 1;
553 head.priority = PROXY_CHANNEL_PRORITY_MESSAGE;
554 EXPECT_EQ(SOFTBUS_OK, TransGetActualDataLen(&head, &actualDataLen));
555 EXPECT_EQ(head.sliceNum * SLICE_LEN, actualDataLen);
556
557 // Test case 2: Valid sliceNum, priority bytes
558 head.sliceNum = 10;
559 head.priority = PROXY_CHANNEL_PRORITY_BYTES;
560 EXPECT_EQ(SOFTBUS_OK, TransGetActualDataLen(&head, &actualDataLen));
561 EXPECT_EQ(head.sliceNum * SLICE_LEN, actualDataLen);
562
563 // Test case 3: Invalid sliceNum (exceeds MAX_MALLOC_SIZE / SLICE_LEN)
564 head.sliceNum = (MAX_MALLOC_SIZE / SLICE_LEN) + 1;
565 head.priority = PROXY_CHANNEL_PRORITY_MESSAGE;
566 EXPECT_EQ(SOFTBUS_INVALID_DATA_HEAD, TransGetActualDataLen(&head, &actualDataLen));
567
568 // Test case 4: Invalid sliceNum (actualLen exceeds maxDataLen)
569 head.sliceNum = (g_proxyMaxMessageBufSize / SLICE_LEN) + 2;
570 head.priority = PROXY_CHANNEL_PRORITY_MESSAGE;
571 EXPECT_EQ(SOFTBUS_INVALID_DATA_HEAD, TransGetActualDataLen(&head, &actualDataLen));
572 }
573
574 /**
575 * @tc.name: ProxyBuildNeedAckTlvData001
576 * @tc.desc: ProxyBuildNeedAckTlvData
577 * @tc.type: FUNC
578 * @tc.require:
579 */
580 HWTEST_F(ClientTransProxyManagerTest, ProxyBuildNeedAckTlvData001, TestSize.Level1)
581 {
582 int32_t bufferSize = 0;
583 int32_t ret = ProxyBuildNeedAckTlvData(nullptr, true, 1, &bufferSize);
584 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
585 }
586
587 /**
588 * @tc.name: ProxyBuildTlvDataHead001
589 * @tc.desc: ProxyBuildTlvDataHead
590 * @tc.type: FUNC
591 * @tc.require:
592 */
593 HWTEST_F(ClientTransProxyManagerTest, ProxyBuildTlvDataHead001, TestSize.Level1)
594 {
595 int32_t bufferSize = 0;
596 DataHead data;
597 int32_t ret = ProxyBuildTlvDataHead(&data, 1, 0, 32, &bufferSize);
598 EXPECT_EQ(ret, SOFTBUS_OK);
599 }
600
601 /**
602 * @tc.name: ClientTransProxyProcSendMsgAck001
603 * @tc.desc: ClientTransProxyProcSendMsgAck
604 * @tc.type: FUNC
605 * @tc.require:
606 */
607 HWTEST_F(ClientTransProxyManagerTest, ClientTransProxyProcSendMsgAck001, TestSize.Level1)
608 {
609 const char *data = "test";
610 int32_t ret = ClientTransProxyProcSendMsgAck(1, nullptr, PROXY_ACK_SIZE, 1, 1);
611 EXPECT_EQ(ret, SOFTBUS_TRANS_PROXY_ASSEMBLE_PACK_DATA_NULL);
612
613 ret = ClientTransProxyProcSendMsgAck(1, data, 1, 1, 1);
614 EXPECT_EQ(ret, SOFTBUS_TRANS_INVALID_DATA_LENGTH);
615
616 ret = ClientTransProxyProcSendMsgAck(1, data, PROXY_ACK_SIZE, 1, 1);
617 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
618
619 ret = ClientTransProxyProcSendMsgAck(1, data, PROXY_ACK_SIZE, 1, 0);
620 EXPECT_EQ(ret, SOFTBUS_TRANS_NODE_NOT_FOUND);
621 }
622
623 /**
624 * @tc.name: ClientTransProxyBytesNotifySession001
625 * @tc.desc: ClientTransProxyBytesNotifySession
626 * @tc.type: FUNC
627 * @tc.require:
628 */
629 HWTEST_F(ClientTransProxyManagerTest, ClientTransProxyBytesNotifySession001, TestSize.Level1)
630 {
631 const char *data = "test";
632 DataHeadTlvPacketHead dataHead;
633 dataHead.dataSeq = 1;
634 dataHead.seq = 1;
635 dataHead.flags = TRANS_SESSION_ACK;
636 int32_t ret = ClientTransProxyBytesNotifySession(1, &dataHead, data, 4);
637 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
638
639 dataHead.flags = TRANS_SESSION_BYTES;
640 ret = ClientTransProxyBytesNotifySession(1, &dataHead, data, sizeof(data));
641 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
642
643 dataHead.flags = TRANS_SESSION_MESSAGE;
644 ret = ClientTransProxyBytesNotifySession(1, &dataHead, data, sizeof(data));
645 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
646 }
647
648 /**
649 * @tc.name: ClientTransProxyProcData001
650 * @tc.desc: ClientTransProxyProcData
651 * @tc.type: FUNC
652 * @tc.require:
653 */
654 HWTEST_F(ClientTransProxyManagerTest, ClientTransProxyProcData001, TestSize.Level1)
655 {
656 int32_t channelId = 1;
657 DataHeadTlvPacketHead dataHead;
658 dataHead.dataLen = 2;
659 const char *data = "test";
660 int32_t ret = ClientTransProxyProcData(channelId, &dataHead, data);
661 EXPECT_EQ(ret, SOFTBUS_TRANS_INVALID_DATA_LENGTH);
662
663 dataHead.dataLen = 34;
664 ret = ClientTransProxyProcData(channelId, &dataHead, data);
665 EXPECT_EQ(ret, SOFTBUS_DECRYPT_ERR);
666 }
667
668 /**
669 * @tc.name: ProxyBuildNeedAckTlvData002
670 * @tc.desc: ProxyBuildNeedAckTlvData
671 * @tc.type: FUNC
672 * @tc.require:
673 */
674 HWTEST_F(ClientTransProxyManagerTest, ProxyBuildNeedAckTlvData002, TestSize.Level1)
675 {
676 DataHead pktHead;
677 bool needAck = true;
678 int32_t ret = ProxyBuildNeedAckTlvData(&pktHead, needAck, TEST_SEQ, nullptr);
679 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
680 }
681
682 /**
683 * @tc.name: ProxyBuildTlvDataHead002
684 * @tc.desc: ProxyBuildTlvDataHead
685 * @tc.type: FUNC
686 * @tc.require:
687 */
688 HWTEST_F(ClientTransProxyManagerTest, ProxyBuildTlvDataHead002, TestSize.Level1)
689 {
690 DataHead pktHead;
691 int32_t flag = 0;
692 int32_t ret = ProxyBuildTlvDataHead(&pktHead, TEST_SEQ, flag, TEST_DATA_LENGTH_2, nullptr);
693 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
694 }
695
696 /**
697 * @tc.name: TransProxyParseTlv001
698 * @tc.desc: TransProxyParseTlv
699 * @tc.type: FUNC
700 * @tc.require:
701 */
702 HWTEST_F(ClientTransProxyManagerTest, TransProxyParseTlv001, TestSize.Level1)
703 {
704 uint32_t newDataHeadSize = 0;
705 int32_t ret = TransProxyParseTlv(TEST_DATA_LENGTH, nullptr, nullptr, &newDataHeadSize);
706 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
707
708 const char *data = "test";
709 ret = TransProxyParseTlv(TEST_DATA_LENGTH, data, nullptr, &newDataHeadSize);
710 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
711
712 DataHeadTlvPacketHead head;
713 ret = TransProxyParseTlv(TEST_DATA_LENGTH_2, data, &head, &newDataHeadSize);
714 EXPECT_EQ(SOFTBUS_OK, ret);
715 }
716
717 /**
718 * @tc.name: ClientTransProxyGetOsTypeByChannelId001
719 * @tc.desc: ClientTransProxyGetOsTypeByChannelId
720 * @tc.type: FUNC
721 * @tc.require:
722 */
723 HWTEST_F(ClientTransProxyManagerTest, ClientTransProxyGetOsTypeByChannelId001, TestSize.Level1)
724 {
725 int32_t channelId = 1;
726 int32_t ret = ClientTransProxyGetOsTypeByChannelId(channelId, nullptr);
727 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
728 }
729
730 /**
731 * @tc.name: ClientTransProxyOnChannelOpened001
732 * @tc.desc: ClientTransProxyOnChannelOpened
733 * @tc.type: FUNC
734 * @tc.require:
735 */
736 HWTEST_F(ClientTransProxyManagerTest, ClientTransProxyOnChannelOpened001, TestSize.Level1)
737 {
738 int32_t channelId = 1;
739 ChannelInfo channelInfo;
740 channelInfo.channelId = channelId;
741 channelInfo.sessionKey = g_sessionKey;
742 channelInfo.isEncrypt = false;
743 channelInfo.isSupportTlv = false;
744 channelInfo.businessType = BUSINESS_TYPE_BYTE;
745 int32_t ret = ClientTransProxyOnChannelOpened(g_proxySessionName, &channelInfo, nullptr);
746 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
747
748 channelInfo.businessType = BUSINESS_TYPE_FILE;
749 ret = ClientTransProxyOnChannelOpened(g_proxySessionName, &channelInfo, nullptr);
750 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
751 }
752
753 /**
754 * @tc.name: ClientTransProxySendBytesAck001
755 * @tc.desc: ClientTransProxySendBytesAck
756 * @tc.type: FUNC
757 * @tc.require:
758 */
759 HWTEST_F(ClientTransProxyManagerTest, ClientTransProxySendBytesAck001, TestSize.Level1)
760 {
761 int32_t channelId = 1;
762 const char *data = "test";
763 DataHeadTlvPacketHead dataHead;
764 dataHead.dataSeq = 1;
765 dataHead.seq = 1;
766 dataHead.flags = TRANS_SESSION_BYTES;
767 dataHead.needAck = true;
768 int32_t ret = ClientTransProxyBytesNotifySession(channelId, &dataHead, data, sizeof(data));
769 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
770 }
771
772 /**
773 * @tc.name: ClientTransProxyBytesNotifySession002
774 * @tc.desc: ClientTransProxyBytesNotifySession
775 * @tc.type: FUNC
776 * @tc.require:
777 */
778 HWTEST_F(ClientTransProxyManagerTest, ClientTransProxyBytesNotifySession002, TestSize.Level1)
779 {
780 int32_t channelId = 1;
781 const char *data = "test";
782 uint32_t invalidFlag = 22;
783 DataHeadTlvPacketHead dataHead;
784 dataHead.dataSeq = 1;
785 dataHead.seq = 1;
786 dataHead.flags = TRANS_SESSION_ASYNC_MESSAGE;
787 int32_t ret = ClientTransProxyBytesNotifySession(channelId, &dataHead, data, sizeof(data));
788 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
789
790 dataHead.flags = invalidFlag;
791 ret = ClientTransProxyBytesNotifySession(channelId, &dataHead, data, sizeof(data));
792 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
793 }
794
795 /**
796 * @tc.name: ClientTransProxyNotifySession001
797 * @tc.desc: ClientTransProxyNotifySession
798 * @tc.type: FUNC
799 * @tc.require:
800 */
801 HWTEST_F(ClientTransProxyManagerTest, ClientTransProxyNotifySession001, TestSize.Level1)
802 {
803 int32_t channelId = 1;
804 SessionPktType flag = TRANS_SESSION_MESSAGE;
805 const char *data = "test";
806 int32_t ret = ClientTransProxyNotifySession(channelId, flag, TEST_SEQ, data, sizeof(data));
807 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
808
809 flag = TRANS_SESSION_ACK;
810 ret = ClientTransProxyNotifySession(channelId, flag, TEST_SEQ, data, PROXY_ACK_SIZE);
811 EXPECT_EQ(SOFTBUS_TRANS_NODE_NOT_FOUND, ret);
812
813 flag = TRANS_SESSION_ASYNC_MESSAGE;
814 ret = ClientTransProxyNotifySession(channelId, flag, TEST_SEQ, data, sizeof(data));
815 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
816
817 int32_t invalidFlag = 22;
818 flag = static_cast<SessionPktType>(invalidFlag);
819 ret = ClientTransProxyNotifySession(channelId, flag, TEST_SEQ, data, sizeof(data));
820 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
821 }
822
823 /**
824 * @tc.name: ClientTransProxyProcessSessionData001
825 * @tc.desc: ClientTransProxyProcessSessionData
826 * @tc.type: FUNC
827 * @tc.require:
828 */
829 HWTEST_F(ClientTransProxyManagerTest, ClientTransProxyProcessSessionData001, TestSize.Level1)
830 {
831 int32_t channelId = 1;
832 PacketHead dataHead;
833 dataHead.dataLen = OVERHEAD_LEN;
834 const char *data = "test";
835 int32_t ret = ClientTransProxyProcessSessionData(channelId, &dataHead, data);
836 EXPECT_EQ(SOFTBUS_TRANS_INVALID_DATA_LENGTH, ret);
837
838 dataHead.dataLen = TEST_DATA_LENGTH_2;
839 dataHead.seq = 1;
840 ret = ClientTransProxyProcessSessionData(channelId, &dataHead, data);
841 EXPECT_EQ(SOFTBUS_DECRYPT_ERR, ret);
842 }
843
844 /**
845 * @tc.name: ClientTransProxyNoSubPacketTlvProc001
846 * @tc.desc: ClientTransProxyNoSubPacketTlvProc
847 * @tc.type: FUNC
848 * @tc.require:
849 */
850 HWTEST_F(ClientTransProxyManagerTest, ClientTransProxyNoSubPacketTlvProc001, TestSize.Level1)
851 {
852 int32_t channelId = 1;
853 int32_t ret = ClientTransProxyNoSubPacketTlvProc(channelId, nullptr, TEST_DATA_LENGTH);
854 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
855
856 const char *data = "test";
857 ret = ClientTransProxyNoSubPacketTlvProc(channelId, data, TEST_DATA_LENGTH);
858 EXPECT_EQ(SOFTBUS_INVALID_DATA_HEAD, ret);
859
860 uint32_t magic = MAGIC_NUMBER;
861 int32_t len = 20;
862 char *magicData = reinterpret_cast<char *>(SoftBusCalloc(len));
863 ASSERT_TRUE(magicData != nullptr);
864 (void)memcpy_s(magicData, MAGICNUM_SIZE, &magic, MAGICNUM_SIZE);
865 ret = ClientTransProxyNoSubPacketTlvProc(channelId, magicData, 0);
866 EXPECT_EQ(SOFTBUS_DATA_NOT_ENOUGH, ret);
867
868 ret = ClientTransProxyNoSubPacketTlvProc(channelId, magicData, TEST_DATA_LENGTH);
869 EXPECT_EQ(SOFTBUS_TRANS_INVALID_DATA_LENGTH, ret);
870 SoftBusFree(magicData);
871 }
872
873 /**
874 * @tc.name: TransProxySliceProcessChkPkgIsValid001
875 * @tc.desc: TransProxySliceProcessChkPkgIsValid
876 * @tc.type: FUNC
877 * @tc.require:
878 */
879 HWTEST_F(ClientTransProxyManagerTest, TransProxySliceProcessChkPkgIsValid001, TestSize.Level1)
880 {
881 // head->sliceNum != processor->sliceNumber || head->sliceSeq != processor->expectedSeq
882 SliceProcessor processor;
883 processor.sliceNumber = 2;
884 processor.expectedSeq = 1;
885 processor.dataLen = 20;
886 processor.bufLen = 10;
887
888 SliceHead head;
889 head.sliceNum = 2;
890 head.sliceSeq = 1;
891 char data[16] = "test";
892 uint32_t len = 20;
893 int32_t ret = TransProxySliceProcessChkPkgIsValid(&processor, &head, data, len);
894 EXPECT_EQ(SOFTBUS_TRANS_PROXY_ASSEMBLE_PACK_EXCEED_LENGTH, ret);
895
896 processor.bufLen = 20;
897 ret = TransProxySliceProcessChkPkgIsValid(&processor, &head, data, len);
898 EXPECT_EQ(SOFTBUS_TRANS_PROXY_ASSEMBLE_PACK_EXCEED_LENGTH, ret);
899
900 processor.bufLen = 50;
901 processor.data = nullptr;
902 ret = TransProxySliceProcessChkPkgIsValid(&processor, &head, data, len);
903 EXPECT_EQ(SOFTBUS_TRANS_PROXY_ASSEMBLE_PACK_DATA_NULL, ret);
904
905 if (strcpy_s(processor.data, processor.bufLen, "test") != EOK) {
906 return;
907 }
908 ret = TransProxySliceProcessChkPkgIsValid(&processor, &head, data, len);
909 EXPECT_EQ(SOFTBUS_TRANS_PROXY_ASSEMBLE_PACK_DATA_NULL, ret);
910 }
911
912 /**
913 * @tc.name: IsValidCheckoutProcess001
914 * @tc.desc: IsValidCheckoutProcess
915 * @tc.type: FUNC
916 * @tc.require:
917 */
918 HWTEST_F(ClientTransProxyManagerTest, IsValidCheckoutProcess001, TestSize.Level1)
919 {
920 int32_t channelId = 1;
921 bool ret = IsValidCheckoutProcess(channelId);
922 EXPECT_EQ(false, ret);
923 }
924
925 /**
926 * @tc.name: TransProxyPackTlvBytes
927 * @tc.desc: ClientTransProxyPackTlvBytes
928 * @tc.type: FUNC
929 * @tc.require:
930 */
931 HWTEST_F(ClientTransProxyManagerTest, TransProxyPackTlvBytes, TestSize.Level1)
932 {
933 int32_t channelId = 1;
934 SessionPktType flag = TRANS_SESSION_ACK;
935 int32_t ret = ClientTransProxyPackTlvBytes(channelId, nullptr, nullptr, flag, TEST_SEQ);
936 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
937
938 ProxyDataInfo dataInfo;
939 ret = ClientTransProxyPackTlvBytes(channelId, &dataInfo, nullptr, flag, TEST_SEQ);
940 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
941
942 ProxyChannelInfoDetail info;
943 (void)memset_s(&info, sizeof(ProxyChannelInfoDetail), 0, sizeof(ProxyChannelInfoDetail));
944 ret = ClientTransProxyPackTlvBytes(channelId, &dataInfo, &info, flag, TEST_SEQ);
945 EXPECT_EQ(SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND, ret);
946 }
947
948 /**
949 * @tc.name: SessionPktTypeToProxyIndex001
950 * @tc.desc: SessionPktTypeToProxyIndex
951 * @tc.type: FUNC
952 * @tc.require:
953 */
954 HWTEST_F(ClientTransProxyManagerTest, SessionPktTypeToProxyIndex001, TestSize.Level1)
955 {
956 SessionPktType packetType = TRANS_SESSION_ACK;
957 int32_t ret = SessionPktTypeToProxyIndex(packetType);
958 EXPECT_EQ(PROXY_CHANNEL_PRORITY_MESSAGE, ret);
959
960 packetType = TRANS_SESSION_BYTES;
961 ret = SessionPktTypeToProxyIndex(packetType);
962 EXPECT_EQ(PROXY_CHANNEL_PRORITY_BYTES, ret);
963
964 packetType = TRANS_SESSION_FILE_FIRST_FRAME;
965 ret = SessionPktTypeToProxyIndex(packetType);
966 EXPECT_EQ(PROXY_CHANNEL_PRORITY_FILE, ret);
967 }
968 } // namespace OHOS