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