1 /*
2 * Copyright (c) 2023 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 #include <chrono>
18 #include <thread>
19
20 #include "accesstoken_kit.h"
21 #include "nativetoken_kit.h"
22 #include "token_setproc.h"
23 #include "avsession_errors.h"
24 #include "avsession_log.h"
25 #include "migrate_avsession_constant.h"
26 #include "migrate_avsession_server.h"
27 #define private public
28 #define protected public
29 #include "softbus_distributed_data_manager.h"
30 #include "softbus_session_manager.h"
31 #undef protected
32 #undef private
33
34 using namespace testing::ext;
35 using namespace OHOS::AVSession;
36
37 static const char* g_perms[] = {"ohos.permission.DISTRIBUTED_SOFTBUS_CENTER", "ohos.permission.DISTRIBUTED_DATASYNC",
38 "ohos.permission.ACCESS_SERVICE_DM"};
39 static const int SIZE = 3;
40 class SoftbusSessionManagerTest : public testing::Test {
41 public:
42 static void SetUpTestCase();
43 static void TearDownTestCase();
44 void SetUp();
45 void TearDown();
46 void NativeTokenGet(const char *perms[], int size);
47
48 std::shared_ptr<SoftbusSessionManager> manager_;
49 std::shared_ptr<SoftbusDistributedDataManager> distributed_;
50 };
51
SetUpTestCase()52 void SoftbusSessionManagerTest::SetUpTestCase() {}
53
TearDownTestCase()54 void SoftbusSessionManagerTest::TearDownTestCase() {}
55
SetUp()56 void SoftbusSessionManagerTest::SetUp()
57 {
58 manager_ = std::make_shared<SoftbusSessionManager>();
59 distributed_ = std::make_shared<SoftbusDistributedDataManager>();
60 NativeTokenGet(g_perms, SIZE);
61 }
62
TearDown()63 void SoftbusSessionManagerTest::TearDown()
64 {
65 manager_ = nullptr;
66 distributed_ = nullptr;
67 NativeTokenGet(nullptr, 0);
68 }
69
NativeTokenGet(const char * perms[],int size)70 void SoftbusSessionManagerTest::NativeTokenGet(const char *perms[], int size)
71 {
72 uint64_t tokenId;
73 NativeTokenInfoParams infoInstance = {
74 .dcapsNum = 0,
75 .permsNum = size,
76 .aclsNum = 0,
77 .dcaps = nullptr,
78 .perms = perms,
79 .acls = nullptr,
80 .aplStr = "system_basic",
81 };
82
83 infoInstance.processName = "softbus_session_manager_test";
84 tokenId = GetAccessTokenId(&infoInstance);
85 SetSelfTokenID(tokenId);
86 OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
87 }
88
89 /**
90 * @tc.name: SoftbusDistributedTest001
91 * @tc.desc:
92 * @tc.type: FUNC
93 * @tc.require:
94 */
95 static HWTEST_F(SoftbusSessionManagerTest, SoftbusDistributedTest001, TestSize.Level0)
96 {
97 SLOGI("SoftbusDistributedTest001 begin");
98 distributed_->Init();
99 std::string pkg = "AVSESSION";
100 distributed_->InitSessionServer(pkg);
101
102 std::shared_ptr<MigrateAVSessionServer> server = std::make_shared<MigrateAVSessionServer>();
103 distributed_->CreateServer(server);
104 EXPECT_EQ(distributed_->serverMap_.size() > 0, true);
105
106 int32_t sessionId = 1;
107 char infoName[] = "Media_Session_RemoteCtrl";
108 char infoNetworkId[] = "testInfoNetworkId";
109 char infoPkgName[] = "testInfoPkgName";
110 PeerSocketInfo info = {
111 .name = infoName,
112 .networkId = infoNetworkId,
113 .pkgName = infoPkgName,
114 .dataType = DATA_TYPE_BYTES,
115 };
116 distributed_->SessionOpened(sessionId, info);
117 distributed_->SessionClosed(sessionId);
118 std::string data = "111";
119 int32_t socket = 1;
120 distributed_->MessageReceived(sessionId, data);
121 distributed_->BytesReceived(sessionId, data);
122 distributed_->OnSessionServerOpened();
123 distributed_->OnSessionServerClosed(sessionId);
124 distributed_->OnMessageHandleReceived(sessionId, data);
125 distributed_->OnBytesServerReceived(socket, data);
126
127 distributed_->ReleaseServer(server);
128 EXPECT_EQ(distributed_->serverMap_.size() == 0, true);
129
130 distributed_->DestroySessionServer(pkg);
131 SLOGI("SoftbusDistributedTest001 end");
132 }
133
134 /**
135 * @tc.name: CreateSessionServer001
136 * @tc.desc:
137 * @tc.type: FUNC
138 * @tc.require:
139 */
140 static HWTEST_F(SoftbusSessionManagerTest, CreateSessionServer001, TestSize.Level0)
141 {
142 SLOGI("CreateSessionServer001 begin");
143 std::string pkg = "111";
144 int32_t ret = manager_->Socket(pkg);
145 EXPECT_EQ(ret <= 0, true);
146 SLOGI("CreateSessionServer001 end");
147 }
148
149 /**
150 * @tc.name: RemoveSessionServer001
151 * @tc.desc:
152 * @tc.type: FUNC
153 * @tc.require:
154 */
155 static HWTEST_F(SoftbusSessionManagerTest, RemoveSessionServer001, TestSize.Level0)
156 {
157 SLOGI("RemoveSessionServer001 begin");
158 int32_t sessionId = 123;
159 std::string data = "";
160 int32_t ret = manager_->SendMessage(sessionId, data);
161 EXPECT_EQ(ret, -1);
162 manager_->Shutdown(sessionId);
163 SLOGI("RemoveSessionServer001 end");
164 }
165
166 /**
167 * @tc.name: SendMessage001
168 * @tc.desc:
169 * @tc.type: FUNC
170 * @tc.require:
171 */
172 static HWTEST_F(SoftbusSessionManagerTest, SendMessage001, TestSize.Level0)
173 {
174 SLOGI("SendMessage001 begin");
175 int32_t sessionId = 123;
176 std::string data = "";
177 int32_t ret = manager_->SendMessage(sessionId, data);
178 EXPECT_EQ(ret, -1);
179 SLOGI("SendMessage001 end");
180 }
181
182 /**
183 * @tc.name: SendByte001
184 * @tc.desc:
185 * @tc.type: FUNC
186 * @tc.require:
187 */
188 static HWTEST_F(SoftbusSessionManagerTest, SendByte001, TestSize.Level0)
189 {
190 SLOGI("SendByte001 begin");
191 int32_t sessionId = 123;
192 std::string data = "";
193 int32_t ret = manager_->SendBytes(sessionId, data);
194 EXPECT_EQ(ret, -1);
195 SLOGI("SendByte001 end");
196 }
197
198 /**
199 * @tc.name: ObtainPeerDeviceId001
200 * @tc.desc:
201 * @tc.type: FUNC
202 * @tc.require:
203 */
204 static HWTEST_F(SoftbusSessionManagerTest, ObtainPeerDeviceId001, TestSize.Level0)
205 {
206 SLOGI("ObtainPeerDeviceId001 begin");
207 int32_t sessionId = 0;
208 std::string deviceId;
209 int32_t ret = manager_->ObtainPeerDeviceId(sessionId, deviceId);
210 EXPECT_EQ(ret, -1);
211 SLOGI("ObtainPeerDeviceId001 end");
212 }
213
214 /**
215 * @tc.name: OnSessionOpened001
216 * @tc.desc:
217 * @tc.type: FUNC
218 * @tc.require:
219 */
220 static HWTEST_F(SoftbusSessionManagerTest, OnSessionOpened001, TestSize.Level0)
221 {
222 SLOGI("OnSessionOpened001 begin");
223 int32_t sessionId = 123;
224 char infoName[] = "Media_Session_RemoteCtrl";
225 char infoNetworkId[] = "testInfoNetworkId";
226 char infoPkgName[] = "testInfoPkgName";
227 PeerSocketInfo info = {
228 .name = infoName,
229 .networkId = infoNetworkId,
230 .pkgName = infoPkgName,
231 .dataType = DATA_TYPE_BYTES,
232 };
233 EXPECT_TRUE(manager_ != nullptr);
234 manager_->OnBind(sessionId, info);
235 SLOGI("OnSessionOpened001 end");
236 }
237
238
239 /**
240 * @tc.name: SendMessage002
241 * @tc.desc: test SendMessage
242 * @tc.type: FUNC
243 * @tc.require:
244 */
245 static HWTEST_F(SoftbusSessionManagerTest, SendMessage002, TestSize.Level0)
246 {
247 SLOGI("SendMessage002 begin");
248 int32_t sessionId = -1;
249 std::string data = "";
250 int32_t ret = manager_->SendMessage(sessionId, data);
251 EXPECT_EQ(ret, -1);
252 SLOGI("SendMessage002 end");
253 }
254
255 /**
256 * @tc.name: SendMessage003
257 * @tc.desc: test SendMessage
258 * @tc.type: FUNC
259 * @tc.require:
260 */
261 static HWTEST_F(SoftbusSessionManagerTest, SendMessage003, TestSize.Level0)
262 {
263 SLOGI("SendMessage003 begin");
264 int32_t sessionId = -1;
265 std::string data = "123";
266 int32_t ret = manager_->SendMessage(sessionId, data);
267 EXPECT_EQ(ret, -1);
268 SLOGI("SendMessage003 end");
269 }
270
271 /**
272 * @tc.name: SendMessage004
273 * @tc.desc: test SendMessage
274 * @tc.type: FUNC
275 * @tc.require:
276 */
277 static HWTEST_F(SoftbusSessionManagerTest, SendMessage004, TestSize.Level0)
278 {
279 SLOGI("SendMessage004 begin");
280 int32_t sessionId = 100;
281 std::string data = "123";
282 int32_t ret = manager_->SendMessage(sessionId, data);
283 EXPECT_EQ(ret, -1);
284 SLOGI("SendMessage004 end");
285 }
286
287 /**
288 * @tc.name: SendByte002
289 * @tc.desc: test SendBytes
290 * @tc.type: FUNC
291 * @tc.require:
292 */
293 static HWTEST_F(SoftbusSessionManagerTest, SendByte002, TestSize.Level0)
294 {
295 SLOGI("SendByte002 begin");
296 int32_t sessionId = -1;
297 std::string data = "";
298 int32_t ret = manager_->SendBytes(sessionId, data);
299 EXPECT_EQ(ret, -1);
300 SLOGI("SendByte002 end");
301 }
302
303 /**
304 * @tc.name: SendByte003
305 * @tc.desc: test SendBytes
306 * @tc.type: FUNC
307 * @tc.require:
308 */
309 static HWTEST_F(SoftbusSessionManagerTest, SendByte003, TestSize.Level0)
310 {
311 SLOGI("SendByte003 begin");
312 int32_t sessionId = -1;
313 std::string data = "123";
314 int32_t ret = manager_->SendBytes(sessionId, data);
315 EXPECT_EQ(ret, -1);
316 SLOGI("SendByte003 end");
317 }
318
319 /**
320 * @tc.name: SendByte004
321 * @tc.desc: test SendBytes
322 * @tc.type: FUNC
323 * @tc.require:
324 */
325 static HWTEST_F(SoftbusSessionManagerTest, SendByte004, TestSize.Level0)
326 {
327 SLOGI("SendByte004 begin");
328 int32_t sessionId = 100;
329 std::string data = "123";
330 int32_t ret = manager_->SendBytes(sessionId, data);
331 EXPECT_EQ(ret, -1);
332 SLOGI("SendByte004 end");
333 }
334
335 /**
336 * @tc.name: ObtainPeerDeviceId002
337 * @tc.desc: test ObtainPeerDeviceId
338 * @tc.type: FUNC
339 * @tc.require:
340 */
341 static HWTEST_F(SoftbusSessionManagerTest, ObtainPeerDeviceId002, TestSize.Level0)
342 {
343 SLOGI("ObtainPeerDeviceId002 begin");
344 int32_t sessionId = 1230;
345 std::string deviceId;
346 int32_t ret = manager_->ObtainPeerDeviceId(sessionId, deviceId);
347 EXPECT_EQ(ret, -1);
348 SLOGI("ObtainPeerDeviceId002 end");
349 }
350
351 /**
352 * @tc.name: AddSessionListener001
353 * @tc.desc: test AddSessionListener
354 * @tc.type: FUNC
355 * @tc.require:
356 */
357 static HWTEST_F(SoftbusSessionManagerTest, AddSessionListener001, TestSize.Level0)
358 {
359 SLOGI("AddSessionListener001 begin");
360 std::shared_ptr<SoftbusSessionListener> softbusSessionListener;
361 manager_->AddSessionListener(softbusSessionListener);
362 EXPECT_EQ(softbusSessionListener, nullptr);
363 SLOGI("AddSessionListener001 end");
364 }
365
366 /**
367 * @tc.name: OnBind001
368 * @tc.desc: test OnBind
369 * @tc.type: FUNC
370 * @tc.require:
371 */
372 static HWTEST_F(SoftbusSessionManagerTest, OnBind001, TestSize.Level0)
373 {
374 SLOGI("OnBind001 begin");
375 int32_t socket = 1231;
376 PeerSocketInfo info;
377 EXPECT_TRUE(manager_ != nullptr);
378 manager_->OnBind(socket, info);
379 SLOGI("OnBind001 end");
380 }
381
382 /**
383 * @tc.name: OnMessage001
384 * @tc.desc: test OnMessage
385 * @tc.type: FUNC
386 * @tc.require:
387 */
388 static HWTEST_F(SoftbusSessionManagerTest, OnMessage001, TestSize.Level0)
389 {
390 SLOGI("OnMessage001 begin");
391 int32_t socket = 1231;
392 void *data = nullptr;
393 int32_t dataLen = 10;
394 EXPECT_TRUE(manager_ != nullptr);
395 manager_->OnMessage(socket, data, dataLen);
396 SLOGI("OnMessage001 end");
397 }
398
399 /**
400 * @tc.name: OnMessage002
401 * @tc.desc: test OnMessage
402 * @tc.type: FUNC
403 * @tc.require:
404 */
405 static HWTEST_F(SoftbusSessionManagerTest, OnMessage002, TestSize.Level0)
406 {
407 SLOGI("OnMessage002 begin");
408 int32_t socket = 1231;
409 int *ptr = &socket;
410 void *data = static_cast<void*>(ptr);
411 int32_t dataLen = 10;
412 EXPECT_TRUE(manager_ != nullptr);
413 manager_->OnMessage(socket, data, dataLen);
414 SLOGI("OnMessage002 end");
415 }
416
417 /**
418 * @tc.name: CreateServer001
419 * @tc.desc: test CreateServer
420 * @tc.type: FUNC
421 * @tc.require:
422 */
423 static HWTEST_F(SoftbusSessionManagerTest, CreateServer001, TestSize.Level0)
424 {
425 SLOGI("CreateServer001 begin");
426 EXPECT_TRUE(distributed_ != nullptr);
427 distributed_->Init();
428 std::string pkg = "AVSESSION";
429 distributed_->InitSessionServer(pkg);
430
431 std::shared_ptr<MigrateAVSessionServer> server;
432 distributed_->CreateServer(server);
433 EXPECT_EQ(server, nullptr);
434 SLOGI("CreateServer001 end");
435 }
436
437 /**
438 * @tc.name: ReleaseServer001
439 * @tc.desc: test ReleaseServer
440 * @tc.type: FUNC
441 * @tc.require:
442 */
443 static HWTEST_F(SoftbusSessionManagerTest, ReleaseServer001, TestSize.Level0)
444 {
445 SLOGI("ReleaseServer001 begin");
446 EXPECT_TRUE(distributed_ != nullptr);
447 distributed_->Init();
448 std::string pkg = "AVSESSION";
449 distributed_->InitSessionServer(pkg);
450 std::shared_ptr<MigrateAVSessionServer> server = std::make_shared<MigrateAVSessionServer>();
451 distributed_->ReleaseServer(server);
452 EXPECT_TRUE(server != nullptr);
453 SLOGI("ReleaseServer001 end");
454 }
455
456 /**
457 * @tc.name: OnBytes001
458 * @tc.desc: set data to nullptr
459 * @tc.type: FUNC
460 * @tc.require:
461 */
462 static HWTEST_F(SoftbusSessionManagerTest, OnBytes001, TestSize.Level0)
463 {
464 SLOGI("OnBytes001 begin");
465 int32_t socket = 1001;
466 void *data = nullptr;
467 int32_t dataLen = 10;
468 manager_->OnBytes(socket, data, dataLen);
469 EXPECT_TRUE(data == nullptr);
470 SLOGI("OnBytes001 end");
471 }
472
473 /**
474 * @tc.name: OnBytes002
475 * @tc.desc: set data to not nullptr
476 * @tc.type: FUNC
477 * @tc.require:
478 */
479 static HWTEST_F(SoftbusSessionManagerTest, OnBytes002, TestSize.Level0)
480 {
481 SLOGI("OnBytes002 begin");
482 int32_t socket = 1001;
483 int32_t dataArr[] = {1, 0, 1, 0};
484 void *data = static_cast<void*>(dataArr);
485 int32_t dataLen = 10;
486 manager_->OnBytes(socket, data, dataLen);
487 EXPECT_TRUE(data != nullptr);
488 SLOGI("OnBytes002 end");
489 }
490
491 /**
492 * @tc.name: Bind001
493 * @tc.desc: the size of peerNetworkId is zero
494 * @tc.type: FUNC
495 * @tc.require:
496 */
497 static HWTEST_F(SoftbusSessionManagerTest, Bind001, TestSize.Level0)
498 {
499 SLOGI("Bind001 begin");
500 std::string peerNetworkId = "";
501 std::string pkgName = "";
502 int32_t ret = manager_->Bind(peerNetworkId, pkgName);
503 EXPECT_TRUE(ret == AVSESSION_ERROR);
504 SLOGI("Bind001 end");
505 }
506
507 /**
508 * @tc.name: Bind002
509 * @tc.desc: the size of peerNetworkId bigger than zero
510 * @tc.type: FUNC
511 * @tc.require:
512 */
513 static HWTEST_F(SoftbusSessionManagerTest, Bind002, TestSize.Level0)
514 {
515 SLOGI("Bind002 begin");
516 std::string peerNetworkId = "0.0.0.0";
517 std::string pkgName = "test";
518 int32_t ret = manager_->Bind(peerNetworkId, pkgName);
519 EXPECT_TRUE(ret == AVSESSION_ERROR);
520 SLOGI("Bind002 end");
521 }
522
523 static HWTEST_F(SoftbusSessionManagerTest, SendBytesForNext001, TestSize.Level0)
524 {
525 SLOGI("SendBytesForNext001 begin");
526 int32_t sessionid = -1;
527 std::string data = "123";
528 int32_t ret = manager_->SendBytesForNext(sessionid, data);
529 EXPECT_EQ(ret, AVSESSION_ERROR);
530 SLOGI("SendBytesForNext001 end");
531 }
532
533 static HWTEST_F(SoftbusSessionManagerTest, SendBytesForNext002, TestSize.Level0)
534 {
535 SLOGI("SendBytesForNext002 begin");
536 int32_t sessionid = 100;
537 std::string data = "";
538 int32_t ret = manager_->SendBytesForNext(sessionid, data);
539 EXPECT_EQ(ret, AVSESSION_ERROR);
540 SLOGI("SendBytesForNext002 end");
541 }
542
543 static HWTEST_F(SoftbusSessionManagerTest, SendBytesForNext003, TestSize.Level0)
544 {
545 SLOGI("SendBytesForNext003 begin");
546 int32_t sessionid = -1;
547 std::string data = "";
548 int32_t ret = manager_->SendBytesForNext(sessionid, data);
549 EXPECT_EQ(ret, AVSESSION_ERROR);
550 SLOGI("SendBytesForNext003 end");
551 }