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);
SetUp()73     void SetUp() override
74     {}
TearDown()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(int sessionId,int result)96 static int OnSessionOpened(int sessionId, int result)
97 {
98     TRANS_LOGI(TRANS_TEST, "session opened, sessionId=%{public}d", sessionId);
99     return SOFTBUS_OK;
100 }
101 
OnSessionClosed(int sessionId)102 static void OnSessionClosed(int sessionId)
103 {
104     TRANS_LOGI(TRANS_TEST, "session closed, sessionId=%{public}d", sessionId);
105 }
106 
OnBytesReceived(int sessionId,const void * data,unsigned int len)107 static void OnBytesReceived(int sessionId, const void *data, unsigned int len)
108 {
109     TRANS_LOGI(TRANS_TEST, "session bytes received, sessionId=%{public}d", sessionId);
110 }
111 
OnMessageReceived(int sessionId,const void * data,unsigned int len)112 static void OnMessageReceived(int 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     ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID, channelType, &sessionId);
194     if (ret != SOFTBUS_OK) {
195         SoftBusFree(session);
196         SoftBusFree(sessionParam);
197         return ret;
198     }
199 
200     SoftBusFree(sessionParam);
201     return sessionId;
202 }
203 
DeleteSessionServerAndSession(const char * sessionName,int32_t sessionId)204 static void DeleteSessionServerAndSession(const char *sessionName, int32_t sessionId)
205 {
206     (void)ClientDeleteSession(sessionId);
207     (void)ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, sessionName);
208 }
209 
GenerateSession(const SessionParam * param)210 static SessionInfo *GenerateSession(const SessionParam *param)
211 {
212     SessionInfo *session = (SessionInfo*)SoftBusMalloc(sizeof(SessionInfo));
213     EXPECT_TRUE(session != NULL);
214     memset_s(session, sizeof(SessionInfo), 0, sizeof(SessionInfo));
215 
216     int ret = strcpy_s(session->info.peerSessionName, SESSION_NAME_SIZE_MAX, param->peerSessionName);
217     EXPECT_EQ(ret, EOK);
218 
219     ret = strcpy_s(session->info.peerDeviceId, DEVICE_ID_SIZE_MAX, param->peerDeviceId);
220     EXPECT_EQ(ret, EOK);
221 
222     ret = strcpy_s(session->info.groupId, GROUP_ID_SIZE_MAX, param->groupId);
223     EXPECT_EQ(ret, EOK);
224 
225     session->sessionId = INVALID_SESSION_ID;
226     session->channelId = INVALID_CHANNEL_ID;
227     session->channelType = CHANNEL_TYPE_BUTT;
228     session->isServer = false;
229     session->enableStatus = ENABLE_STATUS_INIT;
230     session->routeType = ROUTE_TYPE_ALL;
231     session->info.flag = TYPE_BYTES;
232     session->isEncrypt = true;
233     session->algorithm = TRANS_TEST_ALGORITHM;
234     session->fileEncrypt = TRANS_TEST_FILE_ENCRYPT;
235     session->crc = TRANS_TEST_CRC;
236 
237     return session;
238 }
GenerateCommParam(SessionParam * sessionParam)239 static void GenerateCommParam(SessionParam *sessionParam)
240 {
241     sessionParam->sessionName = g_sessionName;
242     sessionParam->peerSessionName = g_sessionName;
243     sessionParam->peerDeviceId = g_deviceId;
244     sessionParam->groupId = g_groupid;
245     sessionParam->attr = &g_sessionAttr;
246 }
247 
248 /**
249  * @tc.name: TransClientSessionServiceTest01
250  * @tc.desc: Transmission sdk session service qos report and open session synchronize with invalid parameters.
251  * @tc.type: FUNC
252  * @tc.require:
253  */
254 HWTEST_F(TransClientSessionServiceTest, TransClientSessionServiceTest01, TestSize.Level1)
255 {
256     int32_t ret = QosReport(TRANS_TEST_SESSION_ID, APP_TYPE_AUTH, TRANS_TEST_INVALID_QUALITY);
257     EXPECT_EQ(ret,  SOFTBUS_INVALID_PARAM);
258     ret = QosReport(TRANS_TEST_SESSION_ID, APP_TYPE_AUTH, QOS_IMPROVE);
259     EXPECT_EQ(ret,  SOFTBUS_TRANS_SESSION_GET_CHANNEL_FAILED);
260     ret = OpenSessionSync(NULL, g_sessionName, g_networkId, g_groupid, &g_sessionAttr);
261     EXPECT_EQ(ret,  SOFTBUS_TRANS_INVALID_SESSION_NAME);
262     ret = OpenSessionSync(g_sessionName, NULL, g_networkId, g_groupid, &g_sessionAttr);
263     EXPECT_EQ(ret,  SOFTBUS_TRANS_INVALID_SESSION_NAME);
264     ret = OpenSessionSync(g_sessionName, g_sessionName, NULL, g_groupid, &g_sessionAttr);
265     EXPECT_EQ(ret,  SOFTBUS_INVALID_PARAM);
266     ret = OpenSessionSync(g_sessionName, g_sessionName, g_networkId, NULL, &g_sessionAttr);
267     EXPECT_EQ(ret,  SOFTBUS_INVALID_PARAM);
268     ret = OpenSessionSync(g_sessionName, g_sessionName, g_networkId, g_groupid, NULL);
269     EXPECT_EQ(ret,  SOFTBUS_INVALID_PARAM);
270     ret = OpenSessionSync(g_sessionName, g_sessionName, g_networkId, g_groupid, &g_sessionAttr);
271     EXPECT_EQ(ret,  SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
272 }
273 
274 /**
275  * @tc.name: TransClientSessionServiceTest02
276  * @tc.desc: Transmission sdk session service qos report.
277  * @tc.type: FUNC
278  * @tc.require:
279  */
280 HWTEST_F(TransClientSessionServiceTest, TransClientSessionServiceTest02, TestSize.Level1)
281 {
282     int32_t ret = TransClientInit();
283     EXPECT_EQ(ret,  SOFTBUS_OK);
284     ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
285     EXPECT_EQ(ret,  SOFTBUS_OK);
286     SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
287     EXPECT_TRUE(sessionParam != NULL);
288     memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
289     GenerateCommParam(sessionParam);
290     SessionInfo *session = GenerateSession(sessionParam);
291     session->channelId = TRANS_TEST_CHANNEL_ID;
292     session->channelType = CHANNEL_TYPE_UDP;
293     session->isServer = true;
294     ret = ClientAddNewSession(g_sessionName, session);
295     EXPECT_EQ(ret,  SOFTBUS_OK);
296     int32_t sessionId = 0;
297     ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, &sessionId);
298     EXPECT_EQ(ret,  SOFTBUS_OK);
299     ret = QosReport(sessionId, APP_TYPE_AUTH, QOS_IMPROVE);
300     EXPECT_EQ(ret,  SOFTBUS_TRANS_INVALID_SESSION_ID);
301     ret = ClientDeleteSession(sessionId);
302     EXPECT_EQ(ret, SOFTBUS_OK);
303     session = GenerateSession(sessionParam);
304     session->channelId = TRANS_TEST_CHANNEL_ID;
305     session->channelType = CHANNEL_TYPE_UDP;
306     ret = ClientAddNewSession(g_sessionName, session);
307     EXPECT_EQ(ret,  SOFTBUS_OK);
308     ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, &sessionId);
309     EXPECT_EQ(ret,  SOFTBUS_OK);
310     ret = QosReport(sessionId, APP_TYPE_AUTH, QOS_IMPROVE);
311     EXPECT_EQ(ret,  SOFTBUS_ACCESS_TOKEN_DENIED);
312     ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
313     EXPECT_EQ(ret,  SOFTBUS_OK);
314     SoftBusFree(sessionParam);
315 }
316 
317 /**
318  * @tc.name: TransClientSessionServiceTest03
319  * @tc.desc: Transmission sdk session service open session synchronize.
320  * @tc.type: FUNC
321  * @tc.require:
322  */
323 HWTEST_F(TransClientSessionServiceTest, TransClientSessionServiceTest03, TestSize.Level1)
324 {
325     int32_t sessionId = 0;
326     SessionEnableStatus isEnabled = ENABLE_STATUS_INIT;
327     SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
328     EXPECT_TRUE(sessionParam != NULL);
329     memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
330     GenerateCommParam(sessionParam);
331     int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
332     EXPECT_EQ(ret,  SOFTBUS_OK);
333     ret = ClientAddSession(sessionParam, &sessionId, &isEnabled);
334     EXPECT_EQ(ret,  SOFTBUS_OK);
335     ret = OpenSessionSync(g_sessionName, g_sessionName, g_networkId, g_groupid, &g_sessionAttr);
336     EXPECT_EQ(ret,  sessionId);
337     ret = ClientDeleteSession(sessionId);
338     EXPECT_EQ(ret, SOFTBUS_OK);
339     ret = OpenSessionSync(g_sessionName, g_sessionName, g_networkId, g_groupid, &g_sessionAttr);
340     EXPECT_EQ(ret, SOFTBUS_ACCESS_TOKEN_DENIED);
341     ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
342     EXPECT_EQ(ret,  SOFTBUS_OK);
343     SoftBusFree(sessionParam);
344 }
345 
346 /**
347  * @tc.name: TransClientSessionServiceTest04
348  * @tc.desc: Transmission sdk session service get session option with different parameters.
349  * @tc.type: FUNC
350  * @tc.require:
351  */
352 HWTEST_F(TransClientSessionServiceTest, TransClientSessionServiceTest04, TestSize.Level1)
353 {
354     uint32_t optionValue = 0;
355     int ret = GetSessionOption(TRANS_TEST_SESSION_ID, SESSION_OPTION_BUTT,
356                                &optionValue, sizeof(optionValue));
357     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
358     ret = GetSessionOption(TRANS_TEST_SESSION_ID, SESSION_OPTION_MAX_SENDBYTES_SIZE,
359                            NULL, sizeof(optionValue));
360     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
361     ret = GetSessionOption(TRANS_TEST_SESSION_ID, SESSION_OPTION_MAX_SENDBYTES_SIZE,
362                            &optionValue, 0);
363     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
364     ret = GetSessionOption(TRANS_TEST_SESSION_ID, SESSION_OPTION_MAX_SENDBYTES_SIZE,
365                            &optionValue, sizeof(optionValue));
366     EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_GET_CHANNEL_FAILED);
367     int32_t sessionId = AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_TCP_DIRECT, false);
368     ASSERT_GT(sessionId, 0);
369     ret = GetSessionOption(sessionId, SESSION_OPTION_MAX_SENDBYTES_SIZE,
370                            &optionValue, sizeof(optionValue));
371     EXPECT_EQ(ret, SOFTBUS_OK);
372     DeleteSessionServerAndSession(g_sessionName, sessionId);
373 }
374 
375 /**
376  * @tc.name: TransClientSessionServiceTest05
377  * @tc.desc: Transmission sdk session service get peer device Id with different parameters.
378  * @tc.type: FUNC
379  * @tc.require:
380  */
381 HWTEST_F(TransClientSessionServiceTest, TransClientSessionServiceTest05, TestSize.Level1)
382 {
383     char networkId[DEVICE_ID_SIZE_MAX] = {0};
384     int ret = GetPeerDeviceId(TRANS_TEST_INVALID_SESSION_ID, networkId, DEVICE_ID_SIZE_MAX);
385     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
386     ret = GetPeerDeviceId(TRANS_TEST_SESSION_ID, NULL, DEVICE_ID_SIZE_MAX);
387     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
388     ret = GetPeerDeviceId(TRANS_TEST_SESSION_ID, networkId, SESSION_NAME_SIZE_MAX + 1);
389     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
390     ret = GetPeerDeviceId(TRANS_TEST_SESSION_ID, networkId, DEVICE_ID_SIZE_MAX);
391     EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
392     int32_t sessionId = AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_BUTT, false);
393     ASSERT_GT(sessionId, 0);
394     ret = GetPeerDeviceId(sessionId, networkId, DEVICE_ID_SIZE_MAX);
395     EXPECT_EQ(ret, SOFTBUS_OK);
396     ret = strcmp(g_deviceId, networkId);
397     EXPECT_EQ(ret, EOK);
398     DeleteSessionServerAndSession(g_sessionName, sessionId);
399 }
400 
401 /**
402  * @tc.name: TransClientSessionServiceTest06
403  * @tc.desc: Transmission sdk session service get peer session name with different parameters.
404  * @tc.type: FUNC
405  * @tc.require:
406  */
407 HWTEST_F(TransClientSessionServiceTest, TransClientSessionServiceTest06, TestSize.Level1)
408 {
409     char sessionName[SESSION_NAME_SIZE_MAX] = {0};
410     int ret = GetPeerSessionName(TRANS_TEST_INVALID_SESSION_ID, sessionName, SESSION_NAME_SIZE_MAX);
411     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
412     ret = GetPeerSessionName(TRANS_TEST_SESSION_ID, NULL, SESSION_NAME_SIZE_MAX);
413     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
414     ret = GetPeerSessionName(TRANS_TEST_SESSION_ID, sessionName, SESSION_NAME_SIZE_MAX + 1);
415     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
416     ret = GetPeerSessionName(TRANS_TEST_SESSION_ID, sessionName, SESSION_NAME_SIZE_MAX);
417     EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
418     int32_t sessionId = AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_BUTT, false);
419     ASSERT_GT(sessionId, 0);
420     ret = GetPeerSessionName(sessionId, sessionName, SESSION_NAME_SIZE_MAX);
421     EXPECT_EQ(ret, SOFTBUS_OK);
422     ret = strcmp(g_sessionName, sessionName);
423     EXPECT_EQ(ret, EOK);
424     DeleteSessionServerAndSession(g_sessionName, sessionId);
425 }
426 
427 /**
428  * @tc.name: TransClientSessionServiceTest04
429  * @tc.desc: Transmission sdk session set action addr bind.
430  * @tc.type: FUNC
431  * @tc.require:
432  */
433 HWTEST_F(TransClientSessionServiceTest, TransClientSessionServiceTest07, TestSize.Level1)
434 {
435     SessionEnableStatus isSessionEnabled = ENABLE_STATUS_INIT;
436     int32_t sessionId = 1;
437     auto *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
438     ASSERT_NE(sessionParam, nullptr);
439     memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
440     GenerateCommParam(sessionParam);
441 
442     int32_t ret = TransClientInit();
443     ASSERT_EQ(ret,  SOFTBUS_OK);
444 
445     ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
446     ASSERT_EQ(ret, SOFTBUS_OK);
447     ret = ClientAddSession(sessionParam, &sessionId, &isSessionEnabled);
448     ASSERT_EQ(ret, SOFTBUS_OK);
449 
450     ret = ClientSetActionIdBySessionId(sessionId, 0);
451     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
452 
453     uint32_t actionId = 1024;
454     ret = ClientSetActionIdBySessionId(sessionId, actionId);
455     EXPECT_EQ(ret, SOFTBUS_OK);
456     int actionIdRet = 0;
457     ret = ClientGetSessionIntegerDataById(sessionId, &actionIdRet, KEY_ACTION_ID);
458     EXPECT_EQ(ret, SOFTBUS_OK);
459     EXPECT_EQ(actionIdRet, actionId);
460 
461     ret = ClientDeleteSession(sessionId);
462     ASSERT_EQ(ret, SOFTBUS_OK);
463 
464     ret = ClientGetSessionIntegerDataById(sessionId, &actionIdRet, KEY_ACTION_ID);
465     EXPECT_NE(ret, SOFTBUS_OK);
466 
467     ret = ClientSetActionIdBySessionId(sessionId, actionId);
468     EXPECT_NE(ret, SOFTBUS_OK);
469 
470     ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
471     ASSERT_EQ(ret, SOFTBUS_OK);
472     SoftBusFree(sessionParam);
473 }
474 }
475