1 /*
2  * Copyright (c) 2022 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 <securec.h>
17 
18 #include <gtest/gtest.h>
19 #include "softbus_def.h"
20 #include "softbus_errcode.h"
21 #include "softbus_trans_def.h"
22 #include "softbus_app_info.h"
23 #include "softbus_server_frame.h"
24 #include "softbus_adapter_mem.h"
25 #include "client_trans_session_manager.h"
26 #include "client_trans_socket_manager.h"
27 #include "client_trans_session_service.h"
28 #include "client_trans_session_callback.h"
29 #include "client_trans_session_callback.c"
30 #include "softbus_config_type.h"
31 #include "trans_log.h"
32 #include "softbus_feature_config.h"
33 #include "softbus_conn_interface.h"
34 #include "auth_interface.h"
35 #include "bus_center_manager.h"
36 #include "trans_session_service.h"
37 
38 #define TRANS_TEST_SESSION_ID 10
39 #define TRANS_TEST_PID 0
40 #define TRANS_TEST_UID 0
41 #define TRANS_TEST_CHANNEL_ID 1000
42 #define TRANS_TEST_FILE_ENCRYPT 10
43 #define TRANS_TEST_ALGORITHM 1
44 #define TRANS_TEST_CRC 1
45 #define TRANS_TEST_EVENT_ID 1
46 #define TRANS_TEST_TV_COUNT 1
47 #define TRANS_TEST_AUTH_DATA "test auth message data"
48 
49 #define TRANS_TEST_INVALID_CHANNEL_ID (-1)
50 
51 #define MAX_SESSION_SERVER_NUM 32
52 
53 using namespace testing::ext;
54 
55 namespace OHOS {
56 
57 const char *g_pkgName = "dms";
58 const char *g_sessionName = "ohos.distributedschedule.dms.test";
59 const char *g_networkId = "ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF0";
60 const char *g_deviceId = "ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF0";
61 const char *g_groupid = "TEST_GROUP_ID";
62 static SessionAttribute g_sessionAttr = {
63     .dataType = TYPE_BYTES,
64 };
65 class TransClientSessionCallbackTest : public testing::Test {
66 public:
TransClientSessionCallbackTest()67     TransClientSessionCallbackTest()
68     {}
~TransClientSessionCallbackTest()69     ~TransClientSessionCallbackTest()
70     {}
71     static void SetUpTestCase(void);
72     static void TearDownTestCase(void);
SetUp()73     void SetUp() override
74     {}
TearDown()75     void TearDown() override
76     {}
77 };
78 
SetUpTestCase(void)79 void TransClientSessionCallbackTest::SetUpTestCase(void)
80 {
81     SoftbusConfigInit();
82     ConnServerInit();
83     AuthInit();
84     BusCenterServerInit();
85     TransServerInit();
86     int32_t ret = TransClientInit();
87     ASSERT_EQ(ret, SOFTBUS_OK);
88 }
89 
TearDownTestCase(void)90 void TransClientSessionCallbackTest::TearDownTestCase(void)
91 {
92     ConnServerDeinit();
93     AuthDeinit();
94     BusCenterServerDeinit();
95     TransServerDeinit();
96 }
97 
OnSessionOpened(int sessionId,int result)98 static int OnSessionOpened(int sessionId, int result)
99 {
100     TRANS_LOGI(TRANS_TEST, "session opened, sessionId=%{public}d", sessionId);
101     return SOFTBUS_OK;
102 }
103 
OnSessionClosed(int sessionId)104 static void OnSessionClosed(int sessionId)
105 {
106     TRANS_LOGI(TRANS_TEST, "session closed, sessionId=%{public}d", sessionId);
107 }
108 
OnBytesReceived(int sessionId,const void * data,unsigned int len)109 static void OnBytesReceived(int sessionId, const void *data, unsigned int len)
110 {
111     TRANS_LOGI(TRANS_TEST, "session bytes received, sessionId=%{public}d", sessionId);
112 }
113 
OnMessageReceived(int sessionId,const void * data,unsigned int len)114 static void OnMessageReceived(int sessionId, const void *data, unsigned int len)
115 {
116     TRANS_LOGI(TRANS_TEST, "session msg received, sessionId=%{public}d", sessionId);
117 }
118 
OnStreamReceived(int sessionId,const StreamData * data,const StreamData * ext,const StreamFrameInfo * param)119 static void OnStreamReceived(int sessionId, const StreamData *data, const StreamData *ext, const StreamFrameInfo *param)
120 {
121     TRANS_LOGI(TRANS_TEST, "session stream received, sessionId=%{public}d", sessionId);
122 }
123 
OnQosEvent(int sessionId,int eventId,int tvCount,const QosTv * tvList)124 static void OnQosEvent(int sessionId, int eventId, int tvCount, const QosTv *tvList)
125 {
126     TRANS_LOGI(TRANS_TEST, "session Qos event emit, sessionId=%{public}d", sessionId);
127 }
128 static ISessionListener g_sessionlistener = {
129     .OnSessionOpened = OnSessionOpened,
130     .OnSessionClosed = OnSessionClosed,
131     .OnBytesReceived = OnBytesReceived,
132     .OnMessageReceived = OnMessageReceived,
133     .OnStreamReceived = OnStreamReceived,
134     .OnQosEvent = OnQosEvent,
135 };
136 
TestGenerateCommParam(SessionParam * sessionParam)137 static void TestGenerateCommParam(SessionParam *sessionParam)
138 {
139     sessionParam->sessionName = g_sessionName;
140     sessionParam->peerSessionName = g_sessionName;
141     sessionParam->peerDeviceId = g_deviceId;
142     sessionParam->groupId = g_groupid;
143     sessionParam->attr = &g_sessionAttr;
144 }
145 
TestGenerateChannInfo(ChannelInfo * channel)146 static int32_t TestGenerateChannInfo(ChannelInfo *channel)
147 {
148     char *sessionName = (char*)SoftBusCalloc(SESSION_NAME_SIZE_MAX * sizeof(char));
149     char *deviceId = (char*)SoftBusCalloc(DEVICE_ID_SIZE_MAX * sizeof(char));
150     char *groupId = (char*)SoftBusCalloc(GROUP_ID_SIZE_MAX * sizeof(char));
151 
152     if (sessionName == NULL || deviceId == NULL || groupId == NULL ||
153         strcpy_s(sessionName, SESSION_NAME_SIZE_MAX, g_sessionName) != EOK ||
154         strcpy_s(deviceId, SESSION_NAME_SIZE_MAX, g_deviceId) != EOK ||
155         strcpy_s(groupId, SESSION_NAME_SIZE_MAX, g_groupid) != EOK) {
156         SoftBusFree(sessionName);
157         SoftBusFree(deviceId);
158         SoftBusFree(groupId);
159         return SOFTBUS_STRCPY_ERR;
160     }
161 
162     channel->peerSessionName = sessionName;
163     channel->peerDeviceId = deviceId;
164     channel->groupId = groupId;
165     channel->channelId = TRANS_TEST_CHANNEL_ID;
166     channel->channelType = CHANNEL_TYPE_BUTT;
167     channel->peerPid = TRANS_TEST_PID;
168     channel->peerUid = TRANS_TEST_UID;
169     channel->isServer = false;
170     channel->businessType = BUSINESS_TYPE_BUTT;
171     channel->routeType = ROUTE_TYPE_ALL;
172     channel->encrypt = TRANS_TEST_FILE_ENCRYPT;
173     channel->algorithm = TRANS_TEST_ALGORITHM;
174     channel->crc = TRANS_TEST_CRC;
175 
176     return SOFTBUS_OK;
177 }
178 
TestGenerateSession(const SessionParam * param)179 static SessionInfo *TestGenerateSession(const SessionParam *param)
180 {
181     SessionInfo *session = (SessionInfo*)SoftBusCalloc(sizeof(SessionInfo));
182     if (session == NULL) {
183         return NULL;
184     }
185 
186     if (strcpy_s(session->info.peerSessionName, SESSION_NAME_SIZE_MAX, param->peerSessionName) != EOK ||
187         strcpy_s(session->info.peerDeviceId, DEVICE_ID_SIZE_MAX, param->peerDeviceId) != EOK ||
188         strcpy_s(session->info.groupId, GROUP_ID_SIZE_MAX, param->groupId) != EOK) {
189         SoftBusFree(session);
190         return NULL;
191     }
192 
193     session->sessionId = TRANS_TEST_SESSION_ID;
194     session->channelId = TRANS_TEST_CHANNEL_ID;
195     session->channelType = CHANNEL_TYPE_BUTT;
196     session->isServer = false;
197     session->enableStatus = ENABLE_STATUS_INIT;
198     session->routeType = ROUTE_TYPE_ALL;
199     session->info.flag = TYPE_BYTES;
200     session->isEncrypt = true;
201     session->algorithm = TRANS_TEST_ALGORITHM;
202     session->fileEncrypt = TRANS_TEST_FILE_ENCRYPT;
203     session->crc = TRANS_TEST_CRC;
204 
205     return session;
206 }
207 
RelesseChannInfo(ChannelInfo * channel)208 static void RelesseChannInfo(ChannelInfo *channel)
209 {
210     if (channel != NULL) {
211         if (channel->peerSessionName != NULL) {
212             SoftBusFree(channel->peerSessionName);
213         }
214         if (channel->peerDeviceId != NULL) {
215             SoftBusFree(channel->peerDeviceId);
216         }
217         if (channel->groupId != NULL) {
218             SoftBusFree(channel->groupId);
219         }
220         SoftBusFree(channel);
221     }
222     channel = NULL;
223 }
224 
225 /**
226  * @tc.name: TransClientSessionCallbackTest01
227  * @tc.desc: Transmission sdk session callback accept session as server with different parameters.
228  * @tc.type: FUNC
229  * @tc.require:
230  */
231 HWTEST_F(TransClientSessionCallbackTest, TransClientSessionCallbackTest01, TestSize.Level1)
232 {
233     int32_t sessionId = 0;
234     SessionParam *sessionParam = (SessionParam*)SoftBusCalloc(sizeof(SessionParam));
235     ASSERT_TRUE(sessionParam != NULL);
236     TestGenerateCommParam(sessionParam);
237     int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
238     ASSERT_EQ(ret, SOFTBUS_OK);
239     ChannelInfo *channel = (ChannelInfo*)SoftBusCalloc(sizeof(ChannelInfo));
240     ASSERT_TRUE(channel != NULL);
241     ret = TestGenerateChannInfo(channel);
242     ASSERT_EQ(ret, SOFTBUS_OK);
243     ret = AcceptSessionAsServer(g_sessionName, channel, TYPE_BUTT, &sessionId);
244     EXPECT_EQ(ret, SOFTBUS_OK);
245     const char *sessionName = "com.huawei.devicegroupmanage";
246     ret = AcceptSessionAsServer(sessionName, channel, TYPE_BUTT, &sessionId);
247     EXPECT_EQ(ret, SOFTBUS_TRANS_SESSIONSERVER_NOT_CREATED);
248     SoftBusFree(channel->groupId);
249     channel->groupId = NULL;
250     ret = AcceptSessionAsServer(g_sessionName, channel, TYPE_BUTT, &sessionId);
251     EXPECT_EQ(ret, SOFTBUS_STRCPY_ERR);
252     ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
253     EXPECT_EQ(ret, SOFTBUS_OK);
254     RelesseChannInfo(channel);
255 }
256 
257 /**
258  * @tc.name: TransClientSessionCallbackTest02
259  * @tc.desc: Transmission sdk session callback get session callback by channe id with different parameters.
260  * @tc.type: FUNC
261  * @tc.require:
262  */
263 HWTEST_F(TransClientSessionCallbackTest, TransClientSessionCallbackTest02, TestSize.Level1)
264 {
265     int32_t sessionId = 0;
266     ISessionListener listener = {0};
267     int32_t ret = GetSessionCallbackByChannelId(TRANS_TEST_INVALID_CHANNEL_ID, CHANNEL_TYPE_BUTT,
268                                                 &sessionId, &listener);
269     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
270     ret = GetSessionCallbackByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_BUTT, NULL, &listener);
271     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
272     ret = GetSessionCallbackByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_BUTT, &sessionId, NULL);
273     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
274     ret = GetSessionCallbackByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_BUTT, &sessionId, &listener);
275     EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
276     ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
277     EXPECT_EQ(ret, SOFTBUS_OK);
278     SessionParam *sessionParam = (SessionParam*)SoftBusCalloc(sizeof(SessionParam));
279     ASSERT_TRUE(sessionParam != NULL);
280     TestGenerateCommParam(sessionParam);
281     SessionInfo *session = TestGenerateSession(sessionParam);
282     ASSERT_TRUE(session != NULL);
283     ret = ClientAddNewSession(g_sessionName, session);
284     ASSERT_EQ(ret, SOFTBUS_OK);
285     ret = GetSessionCallbackByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_BUTT, &sessionId, &listener);
286     EXPECT_EQ(ret, SOFTBUS_OK);
287     ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
288     EXPECT_EQ(ret, SOFTBUS_OK);
289     SoftBusFree(sessionParam);
290 }
291 
292 /**
293  * @tc.name: TransClientSessionCallbackTest03
294  * @tc.desc: Transmission sdk session callback on session opened with invalid parameters.
295  * @tc.type: FUNC
296  * @tc.require:
297  */
298 HWTEST_F(TransClientSessionCallbackTest, TransClientSessionCallbackTest03, TestSize.Level1)
299 {
300     ISessionListener sessionlistener = {
301         .OnSessionOpened = NULL,
302         .OnSessionClosed = OnSessionClosed,
303         .OnBytesReceived = OnBytesReceived,
304         .OnMessageReceived = OnMessageReceived,
305     };
306     ChannelInfo *channel = (ChannelInfo*)SoftBusCalloc(sizeof(ChannelInfo));
307     ASSERT_TRUE(channel != NULL);
308     int32_t ret = TestGenerateChannInfo(channel);
309     ASSERT_EQ(ret, SOFTBUS_OK);
310     ret = TransOnSessionOpened(NULL, channel, TYPE_BUTT);
311     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
312     ret = TransOnSessionOpened(g_sessionName, NULL, TYPE_BUTT);
313     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
314     ret = TransOnSessionOpened(g_sessionName, channel, TYPE_BUTT);
315     EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
316     ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &sessionlistener);
317     ASSERT_EQ(ret, SOFTBUS_OK);
318     SessionParam *sessionParam = (SessionParam*)SoftBusCalloc(sizeof(SessionParam));
319     ASSERT_TRUE(sessionParam != NULL);
320     TestGenerateCommParam(sessionParam);
321     SessionInfo *session = TestGenerateSession(sessionParam);
322     ASSERT_TRUE(session != NULL);
323     ret = ClientAddNewSession(g_sessionName, session);
324     ASSERT_EQ(ret, SOFTBUS_OK);
325     ret = TransOnSessionOpened(g_sessionName, channel, TYPE_BUTT);
326     EXPECT_EQ(ret, SOFTBUS_TRANS_ON_SESSION_OPENED_FAILED);
327     ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
328     EXPECT_EQ(ret, SOFTBUS_OK);
329     RelesseChannInfo(channel);
330     SoftBusFree(sessionParam);
331 }
332 
333 /**
334  * @tc.name: TransClientSessionCallbackTest04
335  * @tc.desc: Transmission sdk session callback on session opened with different parameters.
336  * @tc.type: FUNC
337  * @tc.require:
338  */
339 HWTEST_F(TransClientSessionCallbackTest, TransClientSessionCallbackTest04, TestSize.Level1)
340 {
341     ChannelInfo *channel = (ChannelInfo*)SoftBusCalloc(sizeof(ChannelInfo));
342     ASSERT_TRUE(channel != NULL);
343     int32_t ret = TestGenerateChannInfo(channel);
344     ASSERT_EQ(ret, SOFTBUS_OK);
345     ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
346     ASSERT_EQ(ret, SOFTBUS_OK);
347     SessionParam *sessionParam = (SessionParam*)SoftBusCalloc(sizeof(SessionParam));
348     ASSERT_TRUE(sessionParam != NULL);
349     TestGenerateCommParam(sessionParam);
350     SessionInfo *session = TestGenerateSession(sessionParam);
351     ASSERT_TRUE(session != NULL);
352     ret = ClientAddNewSession(g_sessionName, session);
353     ASSERT_EQ(ret, SOFTBUS_OK);
354     channel->channelType = TYPE_BUTT;
355     ret = TransOnSessionOpened(g_sessionName, channel, TYPE_BYTES);
356     EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
357     channel->isServer = true;
358     ret = TransOnSessionOpened(g_sessionName, channel, TYPE_BYTES);
359     EXPECT_EQ(ret, SOFTBUS_OK);
360     ret = TransOnSessionOpenFailed(TRANS_TEST_CHANNEL_ID, TYPE_BYTES, SOFTBUS_NO_INIT);
361     EXPECT_EQ(ret, SOFTBUS_OK);
362     ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
363     EXPECT_EQ(ret, SOFTBUS_OK);
364     RelesseChannInfo(channel);
365     SoftBusFree(sessionParam);
366 }
367 
368 /**
369  * @tc.name: TransClientSessionCallbackTest05
370  * @tc.desc: Transmission sdk session callback on session closed.
371  * @tc.type: FUNC
372  * @tc.require:
373  */
374 HWTEST_F(TransClientSessionCallbackTest, TransClientSessionCallbackTest05, TestSize.Level1)
375 {
376     int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
377     ASSERT_EQ(ret, SOFTBUS_OK);
378     SessionParam *sessionParam = (SessionParam*)SoftBusCalloc(sizeof(SessionParam));
379     ASSERT_TRUE(sessionParam != NULL);
380     TestGenerateCommParam(sessionParam);
381     SessionInfo *session = TestGenerateSession(sessionParam);
382     ASSERT_TRUE(session != NULL);
383     ret = ClientAddNewSession(g_sessionName, session);
384     ASSERT_EQ(ret, SOFTBUS_OK);
385     ret = TransOnSessionClosed(INVALID_CHANNEL_ID, CHANNEL_TYPE_BUTT, SHUTDOWN_REASON_UNKNOWN);
386     EXPECT_EQ(ret, SOFTBUS_NO_INIT);
387     ret = TransOnSessionClosed(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_BUTT, SHUTDOWN_REASON_UNKNOWN);
388     EXPECT_EQ(ret, SOFTBUS_OK);
389     ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
390     EXPECT_EQ(ret, SOFTBUS_OK);
391     SoftBusFree(sessionParam);
392 }
393 
394 /**
395  * @tc.name: TransClientSessionCallbackTest06
396  * @tc.desc: Transmission sdk session callback process receive file data with different parameter.
397  * @tc.type: FUNC
398  * @tc.require:
399  */
400 HWTEST_F(TransClientSessionCallbackTest, TransClientSessionCallbackTest06, TestSize.Level1)
401 {
402     int32_t sessionId = 0;
403     SessionEnableStatus isEnabled = ENABLE_STATUS_INIT;
404     int32_t ret = ProcessReceivedFileData(TRANS_TEST_SESSION_ID, TRANS_TEST_CHANNEL_ID, TRANS_TEST_AUTH_DATA,
405                                           strlen(TRANS_TEST_AUTH_DATA), TRANS_SESSION_FILE_FIRST_FRAME);
406     EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
407     ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
408     ASSERT_EQ(ret, SOFTBUS_OK);
409     SessionParam *sessionParam = (SessionParam*)SoftBusCalloc(sizeof(SessionParam));
410     ASSERT_TRUE(sessionParam != NULL);
411     TestGenerateCommParam(sessionParam);
412     ret = ClientAddSession(sessionParam, &sessionId, &isEnabled);
413     ASSERT_EQ(ret, SOFTBUS_OK);
414     ret = ProcessReceivedFileData(sessionId, TRANS_TEST_CHANNEL_ID, TRANS_TEST_AUTH_DATA,
415                                   strlen(TRANS_TEST_AUTH_DATA), TRANS_SESSION_FILE_FIRST_FRAME);
416     EXPECT_EQ(ret, SOFTBUS_NO_INIT);
417     ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
418     EXPECT_EQ(ret, SOFTBUS_OK);
419     SoftBusFree(sessionParam);
420 }
421 
422 /**
423  * @tc.name: TransClientSessionCallbackTest07
424  * @tc.desc: Transmission sdk session callback on data received with different parameter.
425  * @tc.type: FUNC
426  * @tc.require:
427  */
428 HWTEST_F(TransClientSessionCallbackTest, TransClientSessionCallbackTest07, TestSize.Level1)
429 {
430     int32_t ret = TransOnDataReceived(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_BUTT, TRANS_TEST_AUTH_DATA,
431                                       strlen(TRANS_TEST_AUTH_DATA), TRANS_SESSION_FILE_FIRST_FRAME);
432     EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
433     ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
434     ASSERT_EQ(ret, SOFTBUS_OK);
435     SessionParam *sessionParam = (SessionParam*)SoftBusCalloc(sizeof(SessionParam));
436     ASSERT_TRUE(sessionParam != NULL);
437     TestGenerateCommParam(sessionParam);
438     SessionInfo *session = TestGenerateSession(sessionParam);
439     ASSERT_TRUE(session != NULL);
440     session->channelType = CHANNEL_TYPE_PROXY;
441     ret = ClientAddNewSession(g_sessionName, session);
442     ASSERT_EQ(ret, SOFTBUS_OK);
443     ret = TransOnDataReceived(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_PROXY, TRANS_TEST_AUTH_DATA,
444                               strlen(TRANS_TEST_AUTH_DATA), TRANS_SESSION_FILE_FIRST_FRAME);
445     EXPECT_EQ(ret, SOFTBUS_NO_INIT);
446 
447     ret = TransOnDataReceived(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_PROXY, TRANS_TEST_AUTH_DATA,
448                               strlen(TRANS_TEST_AUTH_DATA), TRANS_SESSION_FILE_ONGOINE_FRAME);
449     EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
450 
451     ret = TransOnDataReceived(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_PROXY, TRANS_TEST_AUTH_DATA,
452                               strlen(TRANS_TEST_AUTH_DATA), TRANS_SESSION_FILE_LAST_FRAME);
453     EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
454 
455     ret = TransOnDataReceived(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_PROXY, TRANS_TEST_AUTH_DATA,
456                               strlen(TRANS_TEST_AUTH_DATA), TRANS_SESSION_FILE_ONLYONE_FRAME);
457     EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
458 
459     ret = TransOnDataReceived(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_PROXY, TRANS_TEST_AUTH_DATA,
460                               strlen(TRANS_TEST_AUTH_DATA), TRANS_SESSION_BYTES);
461     EXPECT_EQ(ret, SOFTBUS_OK);
462     ret = TransOnDataReceived(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_PROXY, TRANS_TEST_AUTH_DATA,
463                               strlen(TRANS_TEST_AUTH_DATA), TRANS_SESSION_MESSAGE);
464     EXPECT_EQ(ret, SOFTBUS_OK);
465     ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
466     EXPECT_EQ(ret, SOFTBUS_OK);
467     SoftBusFree(sessionParam);
468 }
469 
470 /**
471  * @tc.name: TransClientSessionCallbackTest08
472  * @tc.desc: Transmission sdk session callback on stream received with different parameter.
473  * @tc.type: FUNC
474  * @tc.require:
475  */
476 HWTEST_F(TransClientSessionCallbackTest, TransClientSessionCallbackTest08, TestSize.Level1)
477 {
478     StreamData data = {0};
479     StreamData ext = {0};
480     StreamFrameInfo param = {0};
481     int32_t ret = TransOnOnStreamRecevied(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_BUTT, &data, &ext, &param);
482     EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
483     ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
484     ASSERT_EQ(ret, SOFTBUS_OK);
485     SessionParam *sessionParam = (SessionParam*)SoftBusCalloc(sizeof(SessionParam));
486     ASSERT_TRUE(sessionParam != NULL);
487     TestGenerateCommParam(sessionParam);
488     SessionInfo *session = TestGenerateSession(sessionParam);
489     ASSERT_TRUE(session != NULL);
490     ret = ClientAddNewSession(g_sessionName, session);
491     ASSERT_EQ(ret, SOFTBUS_OK);
492     ret = TransOnOnStreamRecevied(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_BUTT, &data, &ext, &param);
493     EXPECT_EQ(ret, SOFTBUS_OK);
494     ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
495     EXPECT_EQ(ret, SOFTBUS_OK);
496     SoftBusFree(sessionParam);
497 }
498 
499 /**
500  * @tc.name: TransClientSessionCallbackTest09
501  * @tc.desc: Transmission sdk session callback on stream received no callback.
502  * @tc.type: FUNC
503  * @tc.require:
504  */
505 HWTEST_F(TransClientSessionCallbackTest, TransClientSessionCallbackTest09, TestSize.Level1)
506 {
507     StreamData data = {0};
508     StreamData ext = {0};
509     StreamFrameInfo param = {0};
510     ISessionListener sessionlistener = {
511         .OnSessionOpened = OnSessionOpened,
512         .OnSessionClosed = OnSessionClosed,
513         .OnBytesReceived = OnBytesReceived,
514         .OnMessageReceived = OnMessageReceived,
515         .OnStreamReceived = NULL,
516     };
517     int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &sessionlistener);
518     ASSERT_EQ(ret, SOFTBUS_OK);
519     SessionParam *sessionParam = (SessionParam*)SoftBusCalloc(sizeof(SessionParam));
520     ASSERT_TRUE(sessionParam != NULL);
521     TestGenerateCommParam(sessionParam);
522     SessionInfo *session = TestGenerateSession(sessionParam);
523     ASSERT_TRUE(session != NULL);
524     ret = ClientAddNewSession(g_sessionName, session);
525     ASSERT_EQ(ret, SOFTBUS_OK);
526     ret = TransOnOnStreamRecevied(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_BUTT, &data, &ext, &param);
527     EXPECT_EQ(ret, SOFTBUS_NO_INIT);
528     ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
529     EXPECT_EQ(ret, SOFTBUS_OK);
530     SoftBusFree(sessionParam);
531 }
532 
533 /**
534  * @tc.name: TransClientSessionCallbackTest10
535  * @tc.desc: Transmission sdk session callback on qos with different parameter.
536  * @tc.type: FUNC
537  * @tc.require:
538  */
539 HWTEST_F(TransClientSessionCallbackTest, TransClientSessionCallbackTest10, TestSize.Level1)
540 {
541     QosTv *tvList = (QosTv*)SoftBusCalloc(sizeof(QosTv));
542     ASSERT_TRUE(tvList != NULL);
543     int32_t ret = TransOnQosEvent(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_BUTT, TRANS_TEST_EVENT_ID,
544                                   TRANS_TEST_TV_COUNT, tvList);
545     EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
546     ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
547     ASSERT_EQ(ret, SOFTBUS_OK);
548     SessionParam *sessionParam = (SessionParam*)SoftBusCalloc(sizeof(SessionParam));
549     ASSERT_TRUE(sessionParam != NULL);
550     TestGenerateCommParam(sessionParam);
551     SessionInfo *session = TestGenerateSession(sessionParam);
552     ASSERT_TRUE(session != NULL);
553     ret = ClientAddNewSession(g_sessionName, session);
554     ASSERT_EQ(ret, SOFTBUS_OK);
555     ret = TransOnQosEvent(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_BUTT, TRANS_TEST_EVENT_ID, TRANS_TEST_TV_COUNT, tvList);
556     EXPECT_EQ(ret, SOFTBUS_OK);
557     ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
558     EXPECT_EQ(ret, SOFTBUS_OK);
559     SoftBusFree(sessionParam);
560     SoftBusFree(tvList);
561 }
562 
563 /**
564  * @tc.name: TransClientSessionCallbackTest11
565  * @tc.desc: Transmission sdk session callback on qos no callback.
566  * @tc.type: FUNC
567  * @tc.require:
568  */
569 HWTEST_F(TransClientSessionCallbackTest, TransClientSessionCallbackTest11, TestSize.Level1)
570 {
571     QosTv *tvList = (QosTv*)SoftBusCalloc(sizeof(QosTv));
572     ASSERT_TRUE(tvList != NULL);
573     ISessionListener sessionlistener = {
574         .OnSessionOpened = OnSessionOpened,
575         .OnSessionClosed = OnSessionClosed,
576         .OnBytesReceived = OnBytesReceived,
577         .OnMessageReceived = OnMessageReceived,
578         .OnStreamReceived = OnStreamReceived,
579         .OnQosEvent = NULL,
580     };
581     int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &sessionlistener);
582     ASSERT_EQ(ret, SOFTBUS_OK);
583     SessionParam *sessionParam = (SessionParam*)SoftBusCalloc(sizeof(SessionParam));
584     ASSERT_TRUE(sessionParam != NULL);
585     TestGenerateCommParam(sessionParam);
586     SessionInfo *session = TestGenerateSession(sessionParam);
587     ASSERT_TRUE(session != NULL);
588     ret = ClientAddNewSession(g_sessionName, session);
589     ASSERT_EQ(ret, SOFTBUS_OK);
590     ret = TransOnQosEvent(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_BUTT, TRANS_TEST_EVENT_ID, TRANS_TEST_TV_COUNT, tvList);
591     EXPECT_EQ(ret, SOFTBUS_NO_INIT);
592     ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
593     EXPECT_EQ(ret, SOFTBUS_OK);
594     SoftBusFree(sessionParam);
595     SoftBusFree(tvList);
596 }
597 
598 /**
599  * @tc.name: TransClientSessionCallbackTest12
600  * @tc.desc: Transmission sdk session callback on session open failed with no callback.
601  * @tc.type: FUNC
602  * @tc.require:
603  */
604 HWTEST_F(TransClientSessionCallbackTest, TransClientSessionCallbackTest12, TestSize.Level1)
605 {
606     ISessionListener sessionlistener = {
607         .OnSessionOpened = NULL,
608         .OnSessionClosed = OnSessionClosed,
609         .OnBytesReceived = OnBytesReceived,
610         .OnMessageReceived = OnMessageReceived,
611         .OnStreamReceived = OnStreamReceived,
612         .OnQosEvent = OnQosEvent,
613     };
614     int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &sessionlistener);
615     ASSERT_EQ(ret, SOFTBUS_OK);
616     SessionParam *sessionParam = (SessionParam*)SoftBusCalloc(sizeof(SessionParam));
617     ASSERT_TRUE(sessionParam != NULL);
618     TestGenerateCommParam(sessionParam);
619     SessionInfo *session = TestGenerateSession(sessionParam);
620     ASSERT_TRUE(session != NULL);
621     ret = ClientAddNewSession(g_sessionName, session);
622     ASSERT_EQ(ret, SOFTBUS_OK);
623     ret = TransOnSessionOpenFailed(TRANS_TEST_CHANNEL_ID, TYPE_BYTES, SOFTBUS_NO_INIT);
624     EXPECT_EQ(ret, SOFTBUS_OK);
625     ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
626     EXPECT_EQ(ret, SOFTBUS_OK);
627     SoftBusFree(sessionParam);
628 }
629 
630 /**
631  * @tc.name: TransClientSessionCallbackTest13
632  * @tc.desc: Transmission sdk session callback on data received with different parameter.
633  * @tc.type: FUNC
634  * @tc.require:
635  */
636 HWTEST_F(TransClientSessionCallbackTest, TransClientSessionCallbackTest13, TestSize.Level1)
637 {
638     int32_t ret = TransOnDataReceived(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_BUTT, TRANS_TEST_AUTH_DATA,
639                                       strlen(TRANS_TEST_AUTH_DATA), TRANS_SESSION_FILE_FIRST_FRAME);
640     EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
641     ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
642     ASSERT_EQ(ret, SOFTBUS_OK);
643     SessionParam *sessionParam = (SessionParam*)SoftBusCalloc(sizeof(SessionParam));
644     ASSERT_TRUE(sessionParam != NULL);
645     TestGenerateCommParam(sessionParam);
646     SessionInfo *session = TestGenerateSession(sessionParam);
647     ASSERT_TRUE(session != NULL);
648     session->channelType = CHANNEL_TYPE_UDP;
649     ret = ClientAddNewSession(g_sessionName, session);
650     ASSERT_EQ(ret, SOFTBUS_OK);
651 
652     ret = TransOnDataReceived(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, TRANS_TEST_AUTH_DATA,
653                               strlen(TRANS_TEST_AUTH_DATA), TRANS_SESSION_FILE_ALLFILE_SENT);
654     EXPECT_EQ(ret, SOFTBUS_OK);
655 
656     ret = TransOnDataReceived(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, TRANS_TEST_AUTH_DATA,
657                               strlen(TRANS_TEST_AUTH_DATA), TRANS_SESSION_FILE_CRC_CHECK_FRAME);
658     EXPECT_EQ(ret, SOFTBUS_OK);
659 
660     ret = TransOnDataReceived(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, TRANS_TEST_AUTH_DATA,
661                               strlen(TRANS_TEST_AUTH_DATA), TRANS_SESSION_FILE_RESULT_FRAME);
662     EXPECT_EQ(ret, SOFTBUS_OK);
663 
664     ret = TransOnDataReceived(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, TRANS_TEST_AUTH_DATA,
665                               strlen(TRANS_TEST_AUTH_DATA), TRANS_SESSION_FILE_ACK_REQUEST_SENT);
666     EXPECT_EQ(ret, SOFTBUS_OK);
667 
668     ret = TransOnDataReceived(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, TRANS_TEST_AUTH_DATA,
669                               strlen(TRANS_TEST_AUTH_DATA), TRANS_SESSION_FILE_ACK_RESPONSE_SENT);
670     EXPECT_EQ(ret, SOFTBUS_OK);
671 
672     ret = TransOnDataReceived(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, TRANS_TEST_AUTH_DATA,
673                               strlen(TRANS_TEST_AUTH_DATA), (SessionPktType)(TRANS_SESSION_FILE_ACK_RESPONSE_SENT + 1));
674     EXPECT_EQ(ret, SOFTBUS_TRANS_INVALID_SESSION_TYPE);
675 
676     ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
677     EXPECT_EQ(ret, SOFTBUS_OK);
678     SoftBusFree(sessionParam);
679 }
680 
681 /**
682  * @tc.name: TransClientSessionCallbackTest14
683  * @tc.desc: HandleAsyncBindSuccess not found session.
684  * @tc.type: FUNC
685  * @tc.require:
686  */
687 HWTEST_F(TransClientSessionCallbackTest, TransClientSessionCallbackTest14, TestSize.Level1)
688 {
689     SocketLifecycleData lifecycle;
690     lifecycle.bindErrCode = 0;
691     int32_t ret = HandleAsyncBindSuccess(1, NULL, &lifecycle);
692     EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
693 }
694 
695 /**
696  * @tc.name: TransClientSessionCallbackTest15
697  * @tc.desc: HandleSyncBindSuccess not found session.
698  * @tc.type: FUNC
699  * @tc.require:
700  */
701 HWTEST_F(TransClientSessionCallbackTest, TransClientSessionCallbackTest15, TestSize.Level1)
702 {
703     SocketLifecycleData lifecycle;
704     lifecycle.sessionState = SESSION_STATE_CANCELLING;
705     lifecycle.bindErrCode = SOFTBUS_TRANS_STOP_BIND_BY_TIMEOUT;
706     int32_t ret = HandleSyncBindSuccess(1, &lifecycle);
707     EXPECT_EQ(ret, SOFTBUS_OK);
708 
709     lifecycle.sessionState = SESSION_STATE_INIT;
710     ret = HandleSyncBindSuccess(1, &lifecycle);
711     EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
712 }
713 }