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 */
HWTEST_F(SoftbusSessionManagerTest, SoftbusDistributedTest001, TestSize.Level1)95 static HWTEST_F(SoftbusSessionManagerTest, SoftbusDistributedTest001, TestSize.Level1)
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[] = "testInfoName";
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 distributed_->MessageReceived(sessionId, data);
120 distributed_->BytesReceived(sessionId, data);
121 distributed_->OnSessionServerOpened();
122 distributed_->OnSessionServerClosed(sessionId);
123 distributed_->OnMessageHandleReceived(sessionId, data);
124 distributed_->OnBytesServerReceived(data);
125
126 distributed_->ReleaseServer(server);
127 EXPECT_EQ(distributed_->serverMap_.size() == 0, true);
128
129 distributed_->DestroySessionServer(pkg);
130 SLOGI("SoftbusDistributedTest001 end");
131 }
132
133 /**
134 * @tc.name: CreateSessionServer001
135 * @tc.desc:
136 * @tc.type: FUNC
137 * @tc.require:
138 */
HWTEST_F(SoftbusSessionManagerTest, CreateSessionServer001, TestSize.Level1)139 static HWTEST_F(SoftbusSessionManagerTest, CreateSessionServer001, TestSize.Level1)
140 {
141 SLOGI("CreateSessionServer001 begin");
142 std::string pkg = "111";
143 int32_t ret = manager_->Socket(pkg);
144 EXPECT_EQ(ret <= 0, true);
145 SLOGI("CreateSessionServer001 end");
146 }
147
148 /**
149 * @tc.name: RemoveSessionServer001
150 * @tc.desc:
151 * @tc.type: FUNC
152 * @tc.require:
153 */
HWTEST_F(SoftbusSessionManagerTest, RemoveSessionServer001, TestSize.Level1)154 static HWTEST_F(SoftbusSessionManagerTest, RemoveSessionServer001, TestSize.Level1)
155 {
156 SLOGI("RemoveSessionServer001 begin");
157 int32_t sessionId = 123;
158 manager_->Shutdown(sessionId);
159 EXPECT_EQ(sessionId, 123);
160 SLOGI("RemoveSessionServer001 end");
161 }
162
163 /**
164 * @tc.name: SendMessage001
165 * @tc.desc:
166 * @tc.type: FUNC
167 * @tc.require:
168 */
HWTEST_F(SoftbusSessionManagerTest, SendMessage001, TestSize.Level1)169 static HWTEST_F(SoftbusSessionManagerTest, SendMessage001, TestSize.Level1)
170 {
171 SLOGI("SendMessage001 begin");
172 int32_t sessionId = 123;
173 std::string data = "";
174 int32_t ret = manager_->SendMessage(sessionId, data);
175 EXPECT_EQ(ret, -1);
176 SLOGI("SendMessage001 end");
177 }
178
179 /**
180 * @tc.name: SendByte001
181 * @tc.desc:
182 * @tc.type: FUNC
183 * @tc.require:
184 */
HWTEST_F(SoftbusSessionManagerTest, SendByte001, TestSize.Level1)185 static HWTEST_F(SoftbusSessionManagerTest, SendByte001, TestSize.Level1)
186 {
187 SLOGI("SendByte001 begin");
188 int32_t sessionId = 123;
189 std::string data = "";
190 int32_t ret = manager_->SendBytes(sessionId, data);
191 EXPECT_EQ(ret, -1);
192 SLOGI("SendByte001 end");
193 }
194
195 /**
196 * @tc.name: ObtainPeerDeviceId001
197 * @tc.desc:
198 * @tc.type: FUNC
199 * @tc.require:
200 */
HWTEST_F(SoftbusSessionManagerTest, ObtainPeerDeviceId001, TestSize.Level1)201 static HWTEST_F(SoftbusSessionManagerTest, ObtainPeerDeviceId001, TestSize.Level1)
202 {
203 SLOGI("ObtainPeerDeviceId001 begin");
204 int32_t sessionId = 0;
205 std::string deviceId;
206 int32_t ret = manager_->ObtainPeerDeviceId(sessionId, deviceId);
207 EXPECT_EQ(ret, -1);
208 SLOGI("ObtainPeerDeviceId001 end");
209 }
210
211 /**
212 * @tc.name: OnSessionOpened001
213 * @tc.desc:
214 * @tc.type: FUNC
215 * @tc.require:
216 */
HWTEST_F(SoftbusSessionManagerTest, OnSessionOpened001, TestSize.Level1)217 static HWTEST_F(SoftbusSessionManagerTest, OnSessionOpened001, TestSize.Level1)
218 {
219 SLOGI("OnSessionOpened001 begin");
220 int32_t sessionId = 123;
221 char infoName[] = "testInfoName";
222 char infoNetworkId[] = "testInfoNetworkId";
223 char infoPkgName[] = "testInfoPkgName";
224 PeerSocketInfo info = {
225 .name = infoName,
226 .networkId = infoNetworkId,
227 .pkgName = infoPkgName,
228 .dataType = DATA_TYPE_BYTES,
229 };
230 EXPECT_TRUE(manager_ != nullptr);
231 manager_->OnBind(sessionId, info);
232 SLOGI("OnSessionOpened001 end");
233 }
234
235
236 /**
237 * @tc.name: SendMessage002
238 * @tc.desc: test SendMessage
239 * @tc.type: FUNC
240 * @tc.require:
241 */
HWTEST_F(SoftbusSessionManagerTest, SendMessage002, TestSize.Level1)242 static HWTEST_F(SoftbusSessionManagerTest, SendMessage002, TestSize.Level1)
243 {
244 SLOGI("SendMessage002 begin");
245 int32_t sessionId = -1;
246 std::string data = "";
247 int32_t ret = manager_->SendMessage(sessionId, data);
248 EXPECT_EQ(ret, -1);
249 SLOGI("SendMessage002 end");
250 }
251
252 /**
253 * @tc.name: SendMessage003
254 * @tc.desc: test SendMessage
255 * @tc.type: FUNC
256 * @tc.require:
257 */
HWTEST_F(SoftbusSessionManagerTest, SendMessage003, TestSize.Level1)258 static HWTEST_F(SoftbusSessionManagerTest, SendMessage003, TestSize.Level1)
259 {
260 SLOGI("SendMessage003 begin");
261 int32_t sessionId = -1;
262 std::string data = "123";
263 int32_t ret = manager_->SendMessage(sessionId, data);
264 EXPECT_EQ(ret, -1);
265 SLOGI("SendMessage003 end");
266 }
267
268 /**
269 * @tc.name: SendMessage004
270 * @tc.desc: test SendMessage
271 * @tc.type: FUNC
272 * @tc.require:
273 */
HWTEST_F(SoftbusSessionManagerTest, SendMessage004, TestSize.Level1)274 static HWTEST_F(SoftbusSessionManagerTest, SendMessage004, TestSize.Level1)
275 {
276 SLOGI("SendMessage004 begin");
277 int32_t sessionId = 100;
278 std::string data = "123";
279 int32_t ret = manager_->SendMessage(sessionId, data);
280 EXPECT_EQ(ret, -1);
281 SLOGI("SendMessage004 end");
282 }
283
284 /**
285 * @tc.name: SendByte002
286 * @tc.desc: test SendBytes
287 * @tc.type: FUNC
288 * @tc.require:
289 */
HWTEST_F(SoftbusSessionManagerTest, SendByte002, TestSize.Level1)290 static HWTEST_F(SoftbusSessionManagerTest, SendByte002, TestSize.Level1)
291 {
292 SLOGI("SendByte002 begin");
293 int32_t sessionId = -1;
294 std::string data = "";
295 int32_t ret = manager_->SendBytes(sessionId, data);
296 EXPECT_EQ(ret, -1);
297 SLOGI("SendByte002 end");
298 }
299
300 /**
301 * @tc.name: SendByte003
302 * @tc.desc: test SendBytes
303 * @tc.type: FUNC
304 * @tc.require:
305 */
HWTEST_F(SoftbusSessionManagerTest, SendByte003, TestSize.Level1)306 static HWTEST_F(SoftbusSessionManagerTest, SendByte003, TestSize.Level1)
307 {
308 SLOGI("SendByte003 begin");
309 int32_t sessionId = -1;
310 std::string data = "123";
311 int32_t ret = manager_->SendBytes(sessionId, data);
312 EXPECT_EQ(ret, -1);
313 SLOGI("SendByte003 end");
314 }
315
316 /**
317 * @tc.name: SendByte004
318 * @tc.desc: test SendBytes
319 * @tc.type: FUNC
320 * @tc.require:
321 */
HWTEST_F(SoftbusSessionManagerTest, SendByte004, TestSize.Level1)322 static HWTEST_F(SoftbusSessionManagerTest, SendByte004, TestSize.Level1)
323 {
324 SLOGI("SendByte004 begin");
325 int32_t sessionId = 100;
326 std::string data = "123";
327 int32_t ret = manager_->SendBytes(sessionId, data);
328 EXPECT_EQ(ret, -1);
329 SLOGI("SendByte004 end");
330 }
331
332 /**
333 * @tc.name: ObtainPeerDeviceId002
334 * @tc.desc: test ObtainPeerDeviceId
335 * @tc.type: FUNC
336 * @tc.require:
337 */
HWTEST_F(SoftbusSessionManagerTest, ObtainPeerDeviceId002, TestSize.Level1)338 static HWTEST_F(SoftbusSessionManagerTest, ObtainPeerDeviceId002, TestSize.Level1)
339 {
340 SLOGI("ObtainPeerDeviceId002 begin");
341 int32_t sessionId = 1230;
342 std::string deviceId;
343 int32_t ret = manager_->ObtainPeerDeviceId(sessionId, deviceId);
344 EXPECT_EQ(ret, -1);
345 SLOGI("ObtainPeerDeviceId002 end");
346 }
347
348 /**
349 * @tc.name: AddSessionListener001
350 * @tc.desc: test AddSessionListener
351 * @tc.type: FUNC
352 * @tc.require:
353 */
HWTEST_F(SoftbusSessionManagerTest, AddSessionListener001, TestSize.Level1)354 static HWTEST_F(SoftbusSessionManagerTest, AddSessionListener001, TestSize.Level1)
355 {
356 SLOGI("AddSessionListener001 begin");
357 std::shared_ptr<SoftbusSessionListener> softbusSessionListener;
358 manager_->AddSessionListener(softbusSessionListener);
359 EXPECT_EQ(softbusSessionListener, nullptr);
360 SLOGI("AddSessionListener001 end");
361 }
362
363 /**
364 * @tc.name: OnBind001
365 * @tc.desc: test OnBind
366 * @tc.type: FUNC
367 * @tc.require:
368 */
HWTEST_F(SoftbusSessionManagerTest, OnBind001, TestSize.Level1)369 static HWTEST_F(SoftbusSessionManagerTest, OnBind001, TestSize.Level1)
370 {
371 SLOGI("OnBind001 begin");
372 int32_t socket = 1231;
373 PeerSocketInfo info;
374 EXPECT_TRUE(manager_ != nullptr);
375 manager_->OnBind(socket, info);
376 SLOGI("OnBind001 end");
377 }
378
379 /**
380 * @tc.name: OnMessage001
381 * @tc.desc: test OnMessage
382 * @tc.type: FUNC
383 * @tc.require:
384 */
HWTEST_F(SoftbusSessionManagerTest, OnMessage001, TestSize.Level1)385 static HWTEST_F(SoftbusSessionManagerTest, OnMessage001, TestSize.Level1)
386 {
387 SLOGI("OnMessage001 begin");
388 int32_t socket = 1231;
389 void *data = nullptr;
390 int32_t dataLen = 10;
391 EXPECT_TRUE(manager_ != nullptr);
392 manager_->OnMessage(socket, data, dataLen);
393 SLOGI("OnMessage001 end");
394 }
395
396 /**
397 * @tc.name: OnMessage002
398 * @tc.desc: test OnMessage
399 * @tc.type: FUNC
400 * @tc.require:
401 */
HWTEST_F(SoftbusSessionManagerTest, OnMessage002, TestSize.Level1)402 static HWTEST_F(SoftbusSessionManagerTest, OnMessage002, TestSize.Level1)
403 {
404 SLOGI("OnMessage002 begin");
405 int32_t socket = 1231;
406 int *ptr = &socket;
407 void *data = static_cast<void*>(ptr);
408 int32_t dataLen = 10;
409 EXPECT_TRUE(manager_ != nullptr);
410 manager_->OnMessage(socket, data, dataLen);
411 SLOGI("OnMessage002 end");
412 }
413
414 /**
415 * @tc.name: OnBytes001
416 * @tc.desc: test OnMessage
417 * @tc.type: FUNC
418 * @tc.require:
419 */
HWTEST_F(SoftbusSessionManagerTest, OnBytes001, TestSize.Level1)420 static HWTEST_F(SoftbusSessionManagerTest, OnBytes001, TestSize.Level1)
421 {
422 SLOGI("OnBytes001 begin");
423 int32_t socket = 1231;
424 void *data = nullptr;
425 int32_t dataLen = 10;
426 EXPECT_TRUE(manager_ != nullptr);
427 manager_->OnMessage(socket, data, dataLen);
428 SLOGI("OnBytes001 end");
429 }
430
431 /**
432 * @tc.name: OnMessage002
433 * @tc.desc: test OnMessage
434 * @tc.type: FUNC
435 * @tc.require:
436 */
HWTEST_F(SoftbusSessionManagerTest, OnBytes002, TestSize.Level1)437 static HWTEST_F(SoftbusSessionManagerTest, OnBytes002, TestSize.Level1)
438 {
439 SLOGI("OnBytes002 begin");
440 int32_t socket = 1231;
441 int *ptr = &socket;
442 void *data = static_cast<void*>(ptr);
443 int32_t dataLen = 10;
444 EXPECT_TRUE(manager_ != nullptr);
445 manager_->OnMessage(socket, data, dataLen);
446 SLOGI("OnBytes002 end");
447 }
448
449 /**
450 * @tc.name: CreateServer001
451 * @tc.desc: test CreateServer
452 * @tc.type: FUNC
453 * @tc.require:
454 */
HWTEST_F(SoftbusSessionManagerTest, CreateServer001, TestSize.Level1)455 static HWTEST_F(SoftbusSessionManagerTest, CreateServer001, TestSize.Level1)
456 {
457 SLOGI("CreateServer001 begin");
458 EXPECT_TRUE(distributed_ != nullptr);
459 distributed_->Init();
460 std::string pkg = "AVSESSION";
461 distributed_->InitSessionServer(pkg);
462
463 std::shared_ptr<MigrateAVSessionServer> server;
464 distributed_->CreateServer(server);
465 EXPECT_EQ(server, nullptr);
466 SLOGI("CreateServer001 end");
467 }
468
469 /**
470 * @tc.name: ReleaseServer001
471 * @tc.desc: test ReleaseServer
472 * @tc.type: FUNC
473 * @tc.require:
474 */
HWTEST_F(SoftbusSessionManagerTest, ReleaseServer001, TestSize.Level1)475 static HWTEST_F(SoftbusSessionManagerTest, ReleaseServer001, TestSize.Level1)
476 {
477 SLOGI("ReleaseServer001 begin");
478 EXPECT_TRUE(distributed_ != nullptr);
479 distributed_->Init();
480 std::string pkg = "AVSESSION";
481 distributed_->InitSessionServer(pkg);
482 std::shared_ptr<MigrateAVSessionServer> server = std::make_shared<MigrateAVSessionServer>();
483 distributed_->ReleaseServer(server);
484 EXPECT_TRUE(server != nullptr);
485 SLOGI("ReleaseServer001 end");
486 }