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