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