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 "softbus_config_type.h"
29 #include "trans_log.h"
30 #include "softbus_feature_config.h"
31 #include "softbus_conn_interface.h"
32 #include "auth_interface.h"
33 #include "bus_center_manager.h"
34 #include "trans_session_service.h"
35 
36 #define TRANS_TEST_SESSION_ID 10
37 #define TRANS_TEST_PID 0
38 #define TRANS_TEST_UID 0
39 #define TRANS_TEST_CHANNEL_ID 12345
40 #define TRANS_TEST_FILE_ENCRYPT 10
41 #define TRANS_TEST_ALGORITHM 1
42 #define TRANS_TEST_CRC 1
43 #define TRANS_TEST_STATE 1
44 
45 #define TRANS_TEST_INVALID_PID (-1)
46 #define TRANS_TEST_INVALID_UID (-1)
47 #define TRANS_TEST_INVALID_QUALITY (-1)
48 #define TRANS_TEST_INVALID_CHANNEL_ID (-1)
49 #define TRANS_TEST_INVALID_SESSION_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 TransClientSessionServiceTest : public testing::Test {
66 public:
TransClientSessionServiceTest()67     TransClientSessionServiceTest()
68     {}
~TransClientSessionServiceTest()69     ~TransClientSessionServiceTest()
70     {}
71     static void SetUpTestCase(void);
72     static void TearDownTestCase(void);
73     void SetUp() override
74     {}
75     void TearDown() override
76     {}
77 };
78 
SetUpTestCase(void)79 void TransClientSessionServiceTest::SetUpTestCase(void)
80 {
81     SoftbusConfigInit();
82     ConnServerInit();
83     AuthInit();
84     BusCenterServerInit();
85     TransServerInit();
86 }
87 
TearDownTestCase(void)88 void TransClientSessionServiceTest::TearDownTestCase(void)
89 {
90     ConnServerDeinit();
91     AuthDeinit();
92     BusCenterServerDeinit();
93     TransServerDeinit();
94 }
95 
OnSessionOpened(int32_t sessionId, int32_t result)96 static int32_t OnSessionOpened(int32_t sessionId, int32_t result)
97 {
98     TRANS_LOGI(TRANS_TEST, "session opened, sessionId=%{public}d", sessionId);
99     return SOFTBUS_OK;
100 }
101 
OnSessionClosed(int32_t sessionId)102 static void OnSessionClosed(int32_t sessionId)
103 {
104     TRANS_LOGI(TRANS_TEST, "session closed, sessionId=%{public}d", sessionId);
105 }
106 
OnBytesReceived(int32_t sessionId, const void *data, unsigned int len)107 static void OnBytesReceived(int32_t sessionId, const void *data, unsigned int len)
108 {
109     TRANS_LOGI(TRANS_TEST, "session bytes received, sessionId=%{public}d", sessionId);
110 }
111 
OnMessageReceived(int32_t sessionId, const void *data, unsigned int len)112 static void OnMessageReceived(int32_t sessionId, const void *data, unsigned int len)
113 {
114     TRANS_LOGI(TRANS_TEST, "session msg received, sessionId=%{public}d", sessionId);
115 }
116 
117 static ISessionListener g_sessionlistener = {
118     .OnSessionOpened = OnSessionOpened,
119     .OnSessionClosed = OnSessionClosed,
120     .OnBytesReceived = OnBytesReceived,
121     .OnMessageReceived = OnMessageReceived,
122 };
123 
TestGenerateCommParam(SessionParam *sessionParam)124 static void TestGenerateCommParam(SessionParam *sessionParam)
125 {
126     sessionParam->sessionName = g_sessionName;
127     sessionParam->peerSessionName = g_sessionName;
128     sessionParam->peerDeviceId = g_deviceId;
129     sessionParam->groupId = g_groupid;
130     sessionParam->attr = &g_sessionAttr;
131 }
132 
TestGenerateSession(const SessionParam *param)133 static SessionInfo *TestGenerateSession(const SessionParam *param)
134 {
135     SessionInfo *session = (SessionInfo*)SoftBusCalloc(sizeof(SessionInfo));
136     if (session == NULL) {
137         return NULL;
138     }
139 
140     if (strcpy_s(session->info.peerSessionName, SESSION_NAME_SIZE_MAX, param->peerSessionName) != EOK ||
141         strcpy_s(session->info.peerDeviceId, DEVICE_ID_SIZE_MAX, param->peerDeviceId) != EOK ||
142         strcpy_s(session->info.groupId, GROUP_ID_SIZE_MAX, param->groupId) != EOK) {
143         SoftBusFree(session);
144         return NULL;
145     }
146 
147     session->sessionId = TRANS_TEST_SESSION_ID;
148     session->channelId = TRANS_TEST_CHANNEL_ID;
149     session->channelType = CHANNEL_TYPE_BUTT;
150     session->isServer = false;
151     session->enableStatus = ENABLE_STATUS_INIT;
152     session->routeType = ROUTE_TYPE_ALL;
153     session->info.flag = TYPE_BYTES;
154     session->isEncrypt = true;
155     session->algorithm = TRANS_TEST_ALGORITHM;
156     session->fileEncrypt = TRANS_TEST_FILE_ENCRYPT;
157     session->crc = TRANS_TEST_CRC;
158     session->lifecycle.sessionState = SESSION_STATE_INIT;
159     return session;
160 }
161 
AddSessionServerAndSession(const char *sessionName, int32_t channelType, bool isServer)162 static int32_t AddSessionServerAndSession(const char *sessionName, int32_t channelType, bool isServer)
163 {
164     SessionParam *sessionParam = (SessionParam*)SoftBusCalloc(sizeof(SessionParam));
165     if (sessionParam == NULL) {
166         return SOFTBUS_MALLOC_ERR;
167     }
168 
169     TestGenerateCommParam(sessionParam);
170     sessionParam->sessionName = sessionName;
171     int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, sessionName, &g_sessionlistener);
172     if (ret != SOFTBUS_OK) {
173         SoftBusFree(sessionParam);
174         return ret;
175     }
176 
177     SessionInfo *session = TestGenerateSession(sessionParam);
178     if (session == NULL) {
179         SoftBusFree(sessionParam);
180         return SOFTBUS_MALLOC_ERR;
181     }
182 
183     session->channelType = (ChannelType)channelType;
184     session->isServer = isServer;
185     ret = ClientAddNewSession(sessionName, session);
186     if (ret != SOFTBUS_OK) {
187         SoftBusFree(session);
188         SoftBusFree(sessionParam);
189         return ret;
190     }
191 
192     int32_t sessionId = 0;
193     bool isClosing = false;
194     ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID, channelType, &sessionId, isClosing);
195     if (ret != SOFTBUS_OK) {
196         SoftBusFree(session);
197         SoftBusFree(sessionParam);
198         return ret;
199     }
200 
201     SoftBusFree(sessionParam);
202     return sessionId;
203 }
204 
DeleteSessionServerAndSession(const char *sessionName, int32_t sessionId)205 static void DeleteSessionServerAndSession(const char *sessionName, int32_t sessionId)
206 {
207     (void)ClientDeleteSession(sessionId);
208     (void)ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, sessionName);
209 }
210 
GenerateSession(const SessionParam *param)211 static SessionInfo *GenerateSession(const SessionParam *param)
212 {
213     SessionInfo *session = (SessionInfo*)SoftBusMalloc(sizeof(SessionInfo));
214     EXPECT_TRUE(session != NULL);
215     memset_s(session, sizeof(SessionInfo), 0, sizeof(SessionInfo));
216 
217     int32_t ret = strcpy_s(session->info.peerSessionName, SESSION_NAME_SIZE_MAX, param->peerSessionName);
218     EXPECT_EQ(ret, EOK);
219 
220     ret = strcpy_s(session->info.peerDeviceId, DEVICE_ID_SIZE_MAX, param->peerDeviceId);
221     EXPECT_EQ(ret, EOK);
222 
223     ret = strcpy_s(session->info.groupId, GROUP_ID_SIZE_MAX, param->groupId);
224     EXPECT_EQ(ret, EOK);
225 
226     session->sessionId = INVALID_SESSION_ID;
227     session->channelId = INVALID_CHANNEL_ID;
228     session->channelType = CHANNEL_TYPE_BUTT;
229     session->isServer = false;
230     session->enableStatus = ENABLE_STATUS_INIT;
231     session->routeType = ROUTE_TYPE_ALL;
232     session->info.flag = TYPE_BYTES;
233     session->isEncrypt = true;
234     session->algorithm = TRANS_TEST_ALGORITHM;
235     session->fileEncrypt = TRANS_TEST_FILE_ENCRYPT;
236     session->crc = TRANS_TEST_CRC;
237 
238     return session;
239 }
GenerateCommParam(SessionParam *sessionParam)240 static void GenerateCommParam(SessionParam *sessionParam)
241 {
242     sessionParam->sessionName = g_sessionName;
243     sessionParam->peerSessionName = g_sessionName;
244     sessionParam->peerDeviceId = g_deviceId;
245     sessionParam->groupId = g_groupid;
246     sessionParam->attr = &g_sessionAttr;
247 }
248 
249 /**
250  * @tc.name: TransClientSessionServiceTest01
251  * @tc.desc: Transmission sdk session service qos report and open session synchronize with invalid parameters.
252  * @tc.type: FUNC
253  * @tc.require:
254  */
HWTEST_F(TransClientSessionServiceTest, TransClientSessionServiceTest01, TestSize.Level1)255 HWTEST_F(TransClientSessionServiceTest, TransClientSessionServiceTest01, TestSize.Level1)
256 {
257     int32_t ret = QosReport(TRANS_TEST_SESSION_ID, APP_TYPE_AUTH, TRANS_TEST_INVALID_QUALITY);
258     EXPECT_EQ(ret,  SOFTBUS_INVALID_PARAM);
259     ret = QosReport(TRANS_TEST_SESSION_ID, APP_TYPE_AUTH, QOS_IMPROVE);
260     EXPECT_EQ(ret,  SOFTBUS_TRANS_SESSION_GET_CHANNEL_FAILED);
261     ret = OpenSessionSync(NULL, g_sessionName, g_networkId, g_groupid, &g_sessionAttr);
262     EXPECT_EQ(ret,  SOFTBUS_TRANS_INVALID_SESSION_NAME);
263     ret = OpenSessionSync(g_sessionName, NULL, g_networkId, g_groupid, &g_sessionAttr);
264     EXPECT_EQ(ret,  SOFTBUS_TRANS_INVALID_SESSION_NAME);
265     ret = OpenSessionSync(g_sessionName, g_sessionName, NULL, g_groupid, &g_sessionAttr);
266     EXPECT_EQ(ret,  SOFTBUS_INVALID_PARAM);
267     ret = OpenSessionSync(g_sessionName, g_sessionName, g_networkId, NULL, &g_sessionAttr);
268     EXPECT_EQ(ret,  SOFTBUS_INVALID_PARAM);
269     ret = OpenSessionSync(g_sessionName, g_sessionName, g_networkId, g_groupid, NULL);
270     EXPECT_EQ(ret,  SOFTBUS_INVALID_PARAM);
271     ret = OpenSessionSync(g_sessionName, g_sessionName, g_networkId, g_groupid, &g_sessionAttr);
272     EXPECT_EQ(ret,  SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
273 }
274 
275 /**
276  * @tc.name: TransClientSessionServiceTest02
277  * @tc.desc: Transmission sdk session service qos report.
278  * @tc.type: FUNC
279  * @tc.require:
280  */
HWTEST_F(TransClientSessionServiceTest, TransClientSessionServiceTest02, TestSize.Level1)281 HWTEST_F(TransClientSessionServiceTest, TransClientSessionServiceTest02, TestSize.Level1)
282 {
283     int32_t ret = TransClientInit();
284     EXPECT_EQ(ret,  SOFTBUS_OK);
285     ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
286     EXPECT_EQ(ret,  SOFTBUS_OK);
287     SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
288     EXPECT_TRUE(sessionParam != NULL);
289     memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
290     GenerateCommParam(sessionParam);
291     SessionInfo *session = GenerateSession(sessionParam);
292     session->channelId = TRANS_TEST_CHANNEL_ID;
293     session->channelType = CHANNEL_TYPE_UDP;
294     session->isServer = true;
295     ret = ClientAddNewSession(g_sessionName, session);
296     EXPECT_EQ(ret,  SOFTBUS_OK);
297     int32_t sessionId = 0;
298     bool isClosing = false;
299     ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, &sessionId, isClosing);
300     EXPECT_EQ(ret,  SOFTBUS_OK);
301     ret = QosReport(sessionId, APP_TYPE_AUTH, QOS_IMPROVE);
302     EXPECT_EQ(ret,  SOFTBUS_TRANS_INVALID_SESSION_ID);
303     ret = ClientDeleteSession(sessionId);
304     EXPECT_EQ(ret, SOFTBUS_OK);
305     session = GenerateSession(sessionParam);
306     session->channelId = TRANS_TEST_CHANNEL_ID;
307     session->channelType = CHANNEL_TYPE_UDP;
308     ret = ClientAddNewSession(g_sessionName, session);
309     EXPECT_EQ(ret,  SOFTBUS_OK);
310     ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, &sessionId, isClosing);
311     EXPECT_EQ(ret,  SOFTBUS_OK);
312     ret = QosReport(sessionId, APP_TYPE_AUTH, QOS_IMPROVE);
313     EXPECT_EQ(ret,  SOFTBUS_ACCESS_TOKEN_DENIED);
314     ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
315     EXPECT_EQ(ret,  SOFTBUS_OK);
316     SoftBusFree(sessionParam);
317 }
318 
319 /**
320  * @tc.name: TransClientSessionServiceTest03
321  * @tc.desc: Transmission sdk session service open session synchronize.
322  * @tc.type: FUNC
323  * @tc.require:
324  */
HWTEST_F(TransClientSessionServiceTest, TransClientSessionServiceTest03, TestSize.Level1)325 HWTEST_F(TransClientSessionServiceTest, TransClientSessionServiceTest03, TestSize.Level1)
326 {
327     int32_t sessionId = 0;
328     SessionEnableStatus isEnabled = ENABLE_STATUS_INIT;
329     SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
330     EXPECT_TRUE(sessionParam != NULL);
331     memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
332     GenerateCommParam(sessionParam);
333     int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
334     EXPECT_EQ(ret,  SOFTBUS_OK);
335     ret = ClientAddSession(sessionParam, &sessionId, &isEnabled);
336     EXPECT_EQ(ret,  SOFTBUS_OK);
337     ret = OpenSessionSync(g_sessionName, g_sessionName, g_networkId, g_groupid, &g_sessionAttr);
338     EXPECT_EQ(ret,  sessionId);
339     ret = ClientDeleteSession(sessionId);
340     EXPECT_EQ(ret, SOFTBUS_OK);
341     ret = OpenSessionSync(g_sessionName, g_sessionName, g_networkId, g_groupid, &g_sessionAttr);
342     EXPECT_EQ(ret, SOFTBUS_ACCESS_TOKEN_DENIED);
343     ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
344     EXPECT_EQ(ret,  SOFTBUS_OK);
345     SoftBusFree(sessionParam);
346 }
347 
348 /**
349  * @tc.name: TransClientSessionServiceTest04
350  * @tc.desc: Transmission sdk session service get session option with different parameters.
351  * @tc.type: FUNC
352  * @tc.require:
353  */
HWTEST_F(TransClientSessionServiceTest, TransClientSessionServiceTest04, TestSize.Level1)354 HWTEST_F(TransClientSessionServiceTest, TransClientSessionServiceTest04, TestSize.Level1)
355 {
356     uint32_t optionValue = 0;
357     int32_t ret = GetSessionOption(TRANS_TEST_SESSION_ID, SESSION_OPTION_BUTT,
358                                &optionValue, sizeof(optionValue));
359     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
360     ret = GetSessionOption(TRANS_TEST_SESSION_ID, SESSION_OPTION_MAX_SENDBYTES_SIZE,
361                            NULL, sizeof(optionValue));
362     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
363     ret = GetSessionOption(TRANS_TEST_SESSION_ID, SESSION_OPTION_MAX_SENDBYTES_SIZE,
364                            &optionValue, 0);
365     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
366     ret = GetSessionOption(TRANS_TEST_SESSION_ID, SESSION_OPTION_MAX_SENDBYTES_SIZE,
367                            &optionValue, sizeof(optionValue));
368     EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_GET_CHANNEL_FAILED);
369     int32_t sessionId = AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_TCP_DIRECT, false);
370     ASSERT_GT(sessionId, 0);
371     ret = GetSessionOption(sessionId, SESSION_OPTION_MAX_SENDBYTES_SIZE,
372                            &optionValue, sizeof(optionValue));
373     EXPECT_EQ(ret, SOFTBUS_OK);
374     DeleteSessionServerAndSession(g_sessionName, sessionId);
375 }
376 
377 /**
378  * @tc.name: TransClientSessionServiceTest05
379  * @tc.desc: Transmission sdk session service get peer device Id with different parameters.
380  * @tc.type: FUNC
381  * @tc.require:
382  */
HWTEST_F(TransClientSessionServiceTest, TransClientSessionServiceTest05, TestSize.Level1)383 HWTEST_F(TransClientSessionServiceTest, TransClientSessionServiceTest05, TestSize.Level1)
384 {
385     char networkId[DEVICE_ID_SIZE_MAX] = {0};
386     int32_t ret = GetPeerDeviceId(TRANS_TEST_INVALID_SESSION_ID, networkId, DEVICE_ID_SIZE_MAX);
387     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
388     ret = GetPeerDeviceId(TRANS_TEST_SESSION_ID, NULL, DEVICE_ID_SIZE_MAX);
389     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
390     ret = GetPeerDeviceId(TRANS_TEST_SESSION_ID, networkId, SESSION_NAME_SIZE_MAX + 1);
391     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
392     ret = GetPeerDeviceId(TRANS_TEST_SESSION_ID, networkId, DEVICE_ID_SIZE_MAX);
393     EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
394     int32_t sessionId = AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_BUTT, false);
395     ASSERT_GT(sessionId, 0);
396     ret = GetPeerDeviceId(sessionId, networkId, DEVICE_ID_SIZE_MAX);
397     EXPECT_EQ(ret, SOFTBUS_OK);
398     ret = strcmp(g_deviceId, networkId);
399     EXPECT_EQ(ret, EOK);
400     DeleteSessionServerAndSession(g_sessionName, sessionId);
401 }
402 
403 /**
404  * @tc.name: TransClientSessionServiceTest06
405  * @tc.desc: Transmission sdk session service get peer session name with different parameters.
406  * @tc.type: FUNC
407  * @tc.require:
408  */
HWTEST_F(TransClientSessionServiceTest, TransClientSessionServiceTest06, TestSize.Level1)409 HWTEST_F(TransClientSessionServiceTest, TransClientSessionServiceTest06, TestSize.Level1)
410 {
411     char sessionName[SESSION_NAME_SIZE_MAX] = {0};
412     int32_t ret = GetPeerSessionName(TRANS_TEST_INVALID_SESSION_ID, sessionName, SESSION_NAME_SIZE_MAX);
413     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
414     ret = GetPeerSessionName(TRANS_TEST_SESSION_ID, NULL, SESSION_NAME_SIZE_MAX);
415     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
416     ret = GetPeerSessionName(TRANS_TEST_SESSION_ID, sessionName, SESSION_NAME_SIZE_MAX + 1);
417     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
418     ret = GetPeerSessionName(TRANS_TEST_SESSION_ID, sessionName, SESSION_NAME_SIZE_MAX);
419     EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
420     int32_t sessionId = AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_BUTT, false);
421     ASSERT_GT(sessionId, 0);
422     ret = GetPeerSessionName(sessionId, sessionName, SESSION_NAME_SIZE_MAX);
423     EXPECT_EQ(ret, SOFTBUS_OK);
424     ret = strcmp(g_sessionName, sessionName);
425     EXPECT_EQ(ret, EOK);
426     DeleteSessionServerAndSession(g_sessionName, sessionId);
427 }
428 
429 /**
430  * @tc.name: TransClientSessionServiceTest04
431  * @tc.desc: Transmission sdk session set action addr bind.
432  * @tc.type: FUNC
433  * @tc.require:
434  */
HWTEST_F(TransClientSessionServiceTest, TransClientSessionServiceTest07, TestSize.Level1)435 HWTEST_F(TransClientSessionServiceTest, TransClientSessionServiceTest07, TestSize.Level1)
436 {
437     SessionEnableStatus isSessionEnabled = ENABLE_STATUS_INIT;
438     int32_t sessionId = 1;
439     auto *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
440     ASSERT_NE(sessionParam, nullptr);
441     memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
442     GenerateCommParam(sessionParam);
443 
444     int32_t ret = TransClientInit();
445     ASSERT_EQ(ret,  SOFTBUS_OK);
446 
447     ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
448     ASSERT_EQ(ret, SOFTBUS_OK);
449     ret = ClientAddSession(sessionParam, &sessionId, &isSessionEnabled);
450     ASSERT_EQ(ret, SOFTBUS_OK);
451 
452     ret = ClientSetActionIdBySessionId(sessionId, 0);
453     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
454 
455     uint32_t actionId = 1024;
456     ret = ClientSetActionIdBySessionId(sessionId, actionId);
457     EXPECT_EQ(ret, SOFTBUS_OK);
458     int32_t actionIdRet = 0;
459     ret = ClientGetSessionIntegerDataById(sessionId, &actionIdRet, KEY_ACTION_ID);
460     EXPECT_EQ(ret, SOFTBUS_OK);
461     EXPECT_EQ(actionIdRet, actionId);
462 
463     ret = ClientDeleteSession(sessionId);
464     ASSERT_EQ(ret, SOFTBUS_OK);
465 
466     ret = ClientGetSessionIntegerDataById(sessionId, &actionIdRet, KEY_ACTION_ID);
467     EXPECT_NE(ret, SOFTBUS_OK);
468 
469     ret = ClientSetActionIdBySessionId(sessionId, actionId);
470     EXPECT_NE(ret, SOFTBUS_OK);
471 
472     ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
473     ASSERT_EQ(ret, SOFTBUS_OK);
474     SoftBusFree(sessionParam);
475 }
476 
477 }
478