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_log.h"
22 #include "softbus_app_info.h"
23 #include "softbus_server_frame.h"
24 #include "softbus_adapter_mem.h"
25 #include "trans_session_manager.h"
26
27 #define TRANS_TEST_INVALID_PID (-1)
28 #define TRANS_TEST_INVALID_UID (-1)
29
30 #define MAX_SESSION_SERVER_NUM 32
31
32 using namespace testing::ext;
33
34 namespace OHOS {
35
36 const char *g_pkgName = "dms";
37 const char *g_sessionName = "ohos.distributedschedule.dms.test";
38 const char *g_networkid = "ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00";
39 class TransSessionManagerTest : public testing::Test {
40 public:
TransSessionManagerTest()41 TransSessionManagerTest()
42 {}
~TransSessionManagerTest()43 ~TransSessionManagerTest()
44 {}
45 static void SetUpTestCase(void);
46 static void TearDownTestCase(void);
SetUp()47 void SetUp() override
48 {}
TearDown()49 void TearDown() override
50 {}
51 };
52
SetUpTestCase(void)53 void TransSessionManagerTest::SetUpTestCase(void)
54 {
55 InitSoftBusServer();
56 }
57
TearDownTestCase(void)58 void TransSessionManagerTest::TearDownTestCase(void)
59 {
60 }
61
62 /**
63 * @tc.name: TransSessionManagerTest01
64 * @tc.desc: Transmission session manager initialize.
65 * @tc.type: FUNC
66 * @tc.require:
67 */
68 HWTEST_F(TransSessionManagerTest, TransSessionManagerTest01, TestSize.Level1)
69 {
70 int32_t ret = TransSessionMgrInit();
71 EXPECT_EQ(ret, SOFTBUS_OK);
72 TransSessionMgrDeinit();
73 ret = TransSessionMgrInit();
74 EXPECT_EQ(ret, SOFTBUS_OK);
75 TransSessionMgrDeinit();
76 }
77
78 /**
79 * @tc.name: TransSessionManagerTest02
80 * @tc.desc: Transmission session manager judge whether session exists with invalid parameters.
81 * @tc.type: FUNC
82 * @tc.require:
83 */
84 HWTEST_F(TransSessionManagerTest, TransSessionManagerTest02, TestSize.Level1)
85 {
86 bool res = TransSessionServerIsExist(NULL);
87 EXPECT_FALSE(res);
88 res = TransSessionServerIsExist(g_sessionName);
89 EXPECT_FALSE(res);
90 }
91
92 /**
93 * @tc.name: TransSessionManagerTest03
94 * @tc.desc: Transmission session manager add item with invalid parameters.
95 * @tc.type: FUNC
96 * @tc.require:
97 */
98 HWTEST_F(TransSessionManagerTest, TransSessionManagerTest03, TestSize.Level1)
99 {
100 int32_t ret = TransSessionServerAddItem(NULL);
101 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
102 SessionServer *sessionServer = (SessionServer*)SoftBusMalloc(sizeof(SessionServer));
103 memset_s(sessionServer, sizeof(SessionServer), 0, sizeof(SessionServer));
104 ret = TransSessionServerAddItem(sessionServer);
105 EXPECT_EQ(ret, SOFTBUS_NO_INIT);
106 }
107
108 /**
109 * @tc.name: TransSessionManagerTest04
110 * @tc.desc: Transmission session manager del item with invalid parameters.
111 * @tc.type: FUNC
112 * @tc.require:
113 */
114 HWTEST_F(TransSessionManagerTest, TransSessionManagerTest04, TestSize.Level1)
115 {
116 int32_t ret = TransSessionServerDelItem(NULL);
117 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
118 ret = TransSessionServerDelItem(g_sessionName);
119 EXPECT_EQ(ret, SOFTBUS_ERR);
120 }
121
122 /**
123 * @tc.name: TransSessionManagerTest05
124 * @tc.desc: Transmission session manager del item with not existed item.
125 * @tc.type: FUNC
126 * @tc.require:
127 */
128 HWTEST_F(TransSessionManagerTest, TransSessionManagerTest05, TestSize.Level1)
129 {
130 int32_t ret = TransSessionMgrInit();
131 EXPECT_EQ(ret, SOFTBUS_OK);
132 TransSessionServerDelItem(g_sessionName);
133 TransSessionMgrDeinit();
134 }
135
136 /**
137 * @tc.name: TransSessionManagerTest06
138 * @tc.desc: Transmission session manager get package name by session name with invalid parameters.
139 * @tc.type: FUNC
140 * @tc.require:
141 */
142 HWTEST_F(TransSessionManagerTest, TransSessionManagerTest06, TestSize.Level1)
143 {
144 int32_t ret = TransSessionMgrInit();
145 EXPECT_EQ(ret, SOFTBUS_OK);
146 char pkgName[PKG_NAME_SIZE_MAX] = {0};
147 ret = TransGetPkgNameBySessionName(NULL, pkgName, PKG_NAME_SIZE_MAX);
148 EXPECT_EQ(ret, SOFTBUS_ERR);
149 ret = TransGetPkgNameBySessionName(g_sessionName, NULL, PKG_NAME_SIZE_MAX);
150 EXPECT_EQ(ret, SOFTBUS_ERR);
151 ret = TransGetPkgNameBySessionName(g_sessionName, pkgName, 0);
152 EXPECT_EQ(ret, SOFTBUS_ERR);
153 TransSessionMgrDeinit();
154 }
155
156 /**
157 * @tc.name: TransSessionManagerTest07
158 * @tc.desc: Transmission session manager delete item by package name with invalid parameters.
159 * @tc.type: FUNC
160 * @tc.require:
161 */
162 HWTEST_F(TransSessionManagerTest, TransSessionManagerTest07, TestSize.Level1)
163 {
164 int32_t ret = TransSessionMgrInit();
165 EXPECT_EQ(ret, SOFTBUS_OK);
166 SessionServer *sessionServer = (SessionServer*)SoftBusMalloc(sizeof(SessionServer));
167 EXPECT_TRUE(sessionServer != NULL);
168 memset_s(sessionServer, sizeof(SessionServer), 0, sizeof(SessionServer));
169 ret = strcpy_s(sessionServer->sessionName, sizeof(sessionServer->sessionName), g_sessionName);
170 EXPECT_EQ(ret, EOK);
171 ret = strcpy_s(sessionServer->pkgName, sizeof(sessionServer->pkgName), g_pkgName);
172 EXPECT_EQ(ret, EOK);
173 sessionServer->pid = TRANS_TEST_INVALID_PID;
174 ret = TransSessionServerAddItem(sessionServer);
175 EXPECT_EQ(ret, SOFTBUS_OK);
176 bool res = TransSessionServerIsExist(g_sessionName);
177 EXPECT_TRUE(res);
178 TransDelItemByPackageName(NULL);
179 res = TransSessionServerIsExist(g_sessionName);
180 EXPECT_TRUE(res);
181 TransSessionMgrDeinit();
182 TransDelItemByPackageName(g_pkgName);
183 }
184
185 /**
186 * @tc.name: TransSessionManagerTest08
187 * @tc.desc: Transmission session manager get uid and pid by session name with invalid parameters.
188 * @tc.type: FUNC
189 * @tc.require:
190 */
191 HWTEST_F(TransSessionManagerTest, TransSessionManagerTest08, TestSize.Level1)
192 {
193 int32_t pid = 0;
194 int32_t uid = 0;
195 int32_t ret = TransGetUidAndPid(NULL, &uid, &pid);
196 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
197 ret = TransGetUidAndPid(g_sessionName, NULL, &pid);
198 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
199 ret = TransGetUidAndPid(g_sessionName, &uid, NULL);
200 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
201 ret = TransGetUidAndPid(g_sessionName, &uid, &pid);
202 EXPECT_EQ(ret, SOFTBUS_ERR);
203 }
204
205 /**
206 * @tc.name: TransSessionManagerTest09
207 * @tc.desc: Transmission session manager get package name by session name.
208 * @tc.type: FUNC
209 * @tc.require:
210 */
211 HWTEST_F(TransSessionManagerTest, TransSessionManagerTest09, TestSize.Level1)
212 {
213 int32_t ret = TransSessionMgrInit();
214 EXPECT_EQ(ret, SOFTBUS_OK);
215 SessionServer *sessionServer = (SessionServer*)SoftBusMalloc(sizeof(SessionServer));
216 EXPECT_TRUE(sessionServer != NULL);
217 memset_s(sessionServer, sizeof(SessionServer), 0, sizeof(SessionServer));
218 ret = strcpy_s(sessionServer->sessionName, sizeof(sessionServer->sessionName), g_sessionName);
219 EXPECT_EQ(ret, EOK);
220 ret = strcpy_s(sessionServer->pkgName, sizeof(sessionServer->pkgName), g_pkgName);
221 EXPECT_EQ(ret, EOK);
222 ret = TransSessionServerAddItem(sessionServer);
223 EXPECT_EQ(ret, SOFTBUS_OK);
224 char pkgName[PKG_NAME_SIZE_MAX] = {0};
225 ret = TransGetPkgNameBySessionName(g_sessionName, pkgName, PKG_NAME_SIZE_MAX);
226 EXPECT_EQ(ret, SOFTBUS_OK);
227 ret = strncmp(pkgName, g_pkgName, strlen(g_pkgName));
228 EXPECT_EQ(ret, EOK);
229 ret = TransSessionServerDelItem(g_sessionName);
230 EXPECT_EQ(ret, SOFTBUS_OK);
231 TransSessionMgrDeinit();
232 }
233
234 /**
235 * @tc.name: TransSessionManagerTest10
236 * @tc.desc: Transmission session manager delete item by package name.
237 * @tc.type: FUNC
238 * @tc.require:
239 */
240 HWTEST_F(TransSessionManagerTest, TransSessionManagerTest10, TestSize.Level1)
241 {
242 int32_t ret = TransSessionMgrInit();
243 EXPECT_EQ(ret, SOFTBUS_OK);
244 SessionServer *sessionServer = (SessionServer*)SoftBusMalloc(sizeof(SessionServer));
245 EXPECT_TRUE(sessionServer != NULL);
246 memset_s(sessionServer, sizeof(SessionServer), 0, sizeof(SessionServer));
247 ret = strcpy_s(sessionServer->sessionName, sizeof(sessionServer->sessionName), g_sessionName);
248 EXPECT_EQ(ret, EOK);
249 ret = strcpy_s(sessionServer->pkgName, sizeof(sessionServer->pkgName), g_pkgName);
250 EXPECT_EQ(ret, EOK);
251 sessionServer->pid = TRANS_TEST_INVALID_PID;
252 ret = TransSessionServerAddItem(sessionServer);
253 EXPECT_EQ(ret, SOFTBUS_OK);
254 TransDelItemByPackageName(g_pkgName);
255 bool res = TransSessionServerIsExist(g_sessionName);
256 EXPECT_FALSE(res);
257 TransSessionMgrDeinit();
258 }
259
260 /**
261 * @tc.name: TransSessionManagerTest11
262 * @tc.desc: Transmission session manager judge whether session exists.
263 * @tc.type: FUNC
264 * @tc.require:
265 */
266 HWTEST_F(TransSessionManagerTest, TransSessionManagerTest11, TestSize.Level1)
267 {
268 int32_t ret = TransSessionMgrInit();
269 EXPECT_EQ(ret, SOFTBUS_OK);
270 SessionServer *sessionServer = (SessionServer*)SoftBusMalloc(sizeof(SessionServer));
271 EXPECT_TRUE(sessionServer != NULL);
272 memset_s(sessionServer, sizeof(SessionServer), 0, sizeof(SessionServer));
273 ret = strcpy_s(sessionServer->sessionName, sizeof(sessionServer->sessionName), g_sessionName);
274 EXPECT_EQ(ret, EOK);
275 ret = strcpy_s(sessionServer->pkgName, sizeof(sessionServer->pkgName), g_pkgName);
276 EXPECT_EQ(ret, EOK);
277 sessionServer->pid = TRANS_TEST_INVALID_PID;
278 ret = TransSessionServerAddItem(sessionServer);
279 EXPECT_EQ(ret, SOFTBUS_OK);
280 bool res = TransSessionServerIsExist(g_sessionName);
281 EXPECT_TRUE(res);
282 SessionServer *newSessionServer = (SessionServer*)SoftBusMalloc(sizeof(SessionServer));
283 EXPECT_TRUE(newSessionServer != NULL);
284 memset_s(newSessionServer, sizeof(SessionServer), 0, sizeof(SessionServer));
285 ret = strcpy_s(newSessionServer->sessionName, sizeof(newSessionServer->sessionName), g_sessionName);
286 EXPECT_EQ(ret, EOK);
287 ret = strcpy_s(newSessionServer->pkgName, sizeof(newSessionServer->pkgName), g_pkgName);
288 EXPECT_EQ(ret, EOK);
289 newSessionServer->pid = TRANS_TEST_INVALID_PID;
290 ret = TransSessionServerAddItem(newSessionServer);
291 EXPECT_EQ(ret, SOFTBUS_SERVER_NAME_REPEATED);
292 ret = TransSessionServerDelItem(g_sessionName);
293 EXPECT_EQ(ret, SOFTBUS_OK);
294 SoftBusFree(newSessionServer);
295 TransSessionMgrDeinit();
296 }
297 /**
298 * @tc.name: TransSessionManagerTest12
299 * @tc.desc: Transmission session manager get pid and uid by session name.
300 * @tc.type: FUNC
301 * @tc.require:
302 */
303 HWTEST_F(TransSessionManagerTest, TransSessionManagerTest12, TestSize.Level1)
304 {
305 int32_t ret = TransSessionMgrInit();
306 EXPECT_EQ(ret, SOFTBUS_OK);
307 SessionServer *sessionServer = (SessionServer*)SoftBusMalloc(sizeof(SessionServer));
308 EXPECT_TRUE(sessionServer != NULL);
309 memset_s(sessionServer, sizeof(SessionServer), 0, sizeof(SessionServer));
310 ret = strcpy_s(sessionServer->sessionName, sizeof(sessionServer->sessionName), g_sessionName);
311 EXPECT_EQ(ret, EOK);
312 ret = strcpy_s(sessionServer->pkgName, sizeof(sessionServer->pkgName), g_pkgName);
313 EXPECT_EQ(ret, EOK);
314 sessionServer->pid = TRANS_TEST_INVALID_PID;
315 sessionServer->uid = TRANS_TEST_INVALID_UID;
316 ret = TransSessionServerAddItem(sessionServer);
317 EXPECT_EQ(ret, SOFTBUS_OK);
318 int32_t pid = 0;
319 int32_t uid = 0;
320 ret = TransGetUidAndPid(g_sessionName, &uid, &pid);
321 EXPECT_EQ(uid, TRANS_TEST_INVALID_UID);
322 EXPECT_EQ(pid, TRANS_TEST_INVALID_PID);
323 ret = TransSessionServerDelItem(g_sessionName);
324 EXPECT_EQ(ret, SOFTBUS_OK);
325 TransSessionMgrDeinit();
326 }
327
328 /**
329 * @tc.name: TransSessionManagerTest13
330 * @tc.desc: Transmission session manager onLink down with invalid parameters.
331 * @tc.type: FUNC
332 * @tc.require:
333 */
334 HWTEST_F(TransSessionManagerTest, TransSessionManagerTest13, TestSize.Level1)
335 {
336 int32_t ret = TransSessionMgrInit();
337 EXPECT_EQ(ret, SOFTBUS_OK);
338 TransOnLinkDown(NULL, WIFI_P2P);
339 TransSessionMgrDeinit();
340 TransOnLinkDown(g_networkid, WIFI_P2P);
341 }
342 /**
343 * @tc.name: TransSessionManagerTest14
344 * @tc.desc: Transmission session manager onLink down with wrong parameters.
345 * @tc.type: FUNC
346 * @tc.require:
347 */
348 HWTEST_F(TransSessionManagerTest, TransSessionManagerTest14, TestSize.Level1)
349 {
350 int32_t ret = TransSessionMgrInit();
351 EXPECT_EQ(ret, SOFTBUS_OK);
352 SessionServer *sessionServer = (SessionServer*)SoftBusMalloc(sizeof(SessionServer));
353 EXPECT_TRUE(sessionServer != NULL);
354 memset_s(sessionServer, sizeof(SessionServer), 0, sizeof(SessionServer));
355 ret = strcpy_s(sessionServer->sessionName, sizeof(sessionServer->sessionName), g_sessionName);
356 EXPECT_EQ(ret, EOK);
357 ret = strcpy_s(sessionServer->pkgName, sizeof(sessionServer->pkgName), g_pkgName);
358 EXPECT_EQ(ret, EOK);
359 sessionServer->pid = TRANS_TEST_INVALID_PID;
360 sessionServer->uid = TRANS_TEST_INVALID_UID;
361 ret = TransSessionServerAddItem(sessionServer);
362 EXPECT_EQ(ret, SOFTBUS_OK);
363 TransOnLinkDown(g_networkid, WIFI_P2P);
364 }
365
366 /**
367 * @tc.name: TransSessionManagerTest15
368 * @tc.desc: Transmission session manager add item to maxmun.
369 * @tc.type: FUNC
370 * @tc.require:
371 */
372 HWTEST_F(TransSessionManagerTest, TransSessionManagerTest15, TestSize.Level1)
373 {
374 int32_t ret = TransSessionMgrInit();
375 EXPECT_EQ(ret, SOFTBUS_OK);
376 for (int i = 0; i < MAX_SESSION_SERVER_NUM - 1; ++i) {
377 char sessionNme[SESSION_NAME_SIZE_MAX] = {0};
378 char pkgName[PKG_NAME_SIZE_MAX] = {0};
379 ret = sprintf_s(sessionNme, SESSION_NAME_SIZE_MAX, "%s%d", g_sessionName, i);
380 EXPECT_GT(ret, 0);
381 ret = sprintf_s(pkgName, PKG_NAME_SIZE_MAX, "%s%d", g_pkgName, i);
382 EXPECT_GT(ret, 0);
383 SessionServer *sessionServer = (SessionServer*)SoftBusMalloc(sizeof(SessionServer));
384 EXPECT_TRUE(sessionServer != NULL);
385 memset_s(sessionServer, sizeof(SessionServer), 0, sizeof(SessionServer));
386 ret = strcpy_s(sessionServer->sessionName, sizeof(sessionServer->sessionName), sessionNme);
387 EXPECT_EQ(ret, EOK);
388 ret = strcpy_s(sessionServer->pkgName, sizeof(sessionServer->pkgName), pkgName);
389 EXPECT_EQ(ret, EOK);
390 ret = TransSessionServerAddItem(sessionServer);
391 EXPECT_EQ(ret, SOFTBUS_OK);
392 }
393
394 SessionServer *sessionServer = (SessionServer*)SoftBusMalloc(sizeof(SessionServer));
395 EXPECT_TRUE(sessionServer != NULL);
396 memset_s(sessionServer, sizeof(SessionServer), 0, sizeof(SessionServer));
397 ret = strcpy_s(sessionServer->sessionName, sizeof(sessionServer->sessionName), g_sessionName);
398 EXPECT_EQ(ret, EOK);
399 ret = strcpy_s(sessionServer->pkgName, sizeof(sessionServer->pkgName), g_pkgName);
400 EXPECT_EQ(ret, EOK);
401 ret = TransSessionServerAddItem(sessionServer);
402 EXPECT_EQ(ret, SOFTBUS_INVALID_NUM);
403 SoftBusFree(sessionServer);
404
405 for (int i = 0; i < MAX_SESSION_SERVER_NUM - 1; ++i) {
406 char sessionNme[SESSION_NAME_SIZE_MAX] = {0};
407 ret = sprintf_s(sessionNme, SESSION_NAME_SIZE_MAX, "%s%d", g_sessionName, i);
408 EXPECT_GT(ret, 0);
409 ret = TransSessionServerDelItem(sessionNme);
410 EXPECT_EQ(ret, SOFTBUS_OK);
411 }
412 TransSessionMgrDeinit();
413 }
414 }