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