1 /*
2 * Copyright (c) 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 #include <fstream>
18 #include "avsession_descriptor.h"
19 #include "avsession_log.h"
20 #include "avsession_errors.h"
21 #include "avsession_service.h"
22 #include "system_ability_definition.h"
23
24 using namespace testing::ext;
25
26 namespace OHOS::AVSession {
27 static char g_testSessionTag[] = "test";
28 static char g_testAnotherBundleName[] = "testAnother.ohos.avsession";
29 static char g_testAnotherAbilityName[] = "testAnother.ability";
30 static std::shared_ptr<AVSessionService> g_AVSessionService;
31
32 class AVSessionServiceSupplementTest : public testing::Test {
33 public:
34 static void SetUpTestCase();
35 static void TearDownTestCase();
36 void SetUp() override;
37 void TearDown() override;
38 };
39
SetUpTestCase()40 void AVSessionServiceSupplementTest::SetUpTestCase()
41 {
42 SLOGI("set up AVSessionServiceTest with OnStart");
43 system("killall -9 com.example.hiMusicDemo");
44 g_AVSessionService = std::make_shared<AVSessionService>(OHOS::AVSESSION_SERVICE_ID);
45 }
46
TearDownTestCase()47 void AVSessionServiceSupplementTest::TearDownTestCase()
48 {
49 }
50
SetUp()51 void AVSessionServiceSupplementTest::SetUp()
52 {
53 }
54
TearDown()55 void AVSessionServiceSupplementTest::TearDown()
56 {
57 }
58
59 /**
60 * @tc.name: GetService001
61 * @tc.desc: Test GetService
62 * @tc.type: FUNC
63 */
64 static HWTEST_F(AVSessionServiceSupplementTest, GetService001, TestSize.Level0)
65 {
66 SLOGI("GetService001 begin!");
67 std::string id = "";
68 auto ret = g_AVSessionService->GetService(id);
69 EXPECT_NE(ret, nullptr);
70 SLOGI("GetService001 end!");
71 }
72
73 /**
74 * @tc.name: IsLocalDevice001
75 * @tc.desc: Test IsLocalDevice
76 * @tc.type: FUNC
77 */
78 static HWTEST_F(AVSessionServiceSupplementTest, IsLocalDevice001, TestSize.Level0)
79 {
80 SLOGI("IsLocalDevice001 begin!");
81 std::string id;
82 int32_t getSuccess = g_AVSessionService->GetLocalNetworkId(id);
83 EXPECT_NE(getSuccess, AVSESSION_SUCCESS);
84 bool ret = g_AVSessionService->IsLocalDevice(id);
85 EXPECT_EQ(ret, true);
86 SLOGI("IsLocalDevice001 end!");
87 }
88
89 /**
90 * @tc.name: GetTrustedDeviceName001
91 * @tc.desc: Test GetTrustedDeviceName
92 * @tc.type: FUNC
93 */
94 static HWTEST_F(AVSessionServiceSupplementTest, GetTrustedDeviceName001, TestSize.Level0)
95 {
96 SLOGI("GetTrustedDeviceName001 begin!");
97 std::string networkId = "";
98 std::string deviceName = "";
99 int32_t ret = g_AVSessionService->GetTrustedDeviceName(networkId, deviceName);
100 EXPECT_EQ(ret, AVSESSION_SUCCESS);
101 SLOGI("GetTrustedDeviceName001 end!");
102 }
103
104 /**
105 * @tc.name: SetDeviceInfo001
106 * @tc.desc: Test SetDeviceInfo
107 * @tc.type: FUNC
108 */
109 static HWTEST_F(AVSessionServiceSupplementTest, SetDeviceInfo001, TestSize.Level0)
110 {
111 SLOGI("SetDeviceInfo001 begin!");
112 AudioStandard::AudioDeviceDescriptor descriptor;
113 std::vector<AudioStandard::AudioDeviceDescriptor> castAudioDescriptors;
114 castAudioDescriptors.push_back(descriptor);
115
116 OHOS::AppExecFwk::ElementName elementName;
117 elementName.SetBundleName(g_testAnotherBundleName);
118 elementName.SetAbilityName(g_testAnotherAbilityName);
119 sptr<AVSessionItem> avsessionItem = g_AVSessionService->CreateSessionInner(
120 g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
121
122 EXPECT_NE(avsessionItem, nullptr);
123
124 g_AVSessionService->SetDeviceInfo(castAudioDescriptors, avsessionItem);
125 avsessionItem->Destroy();
126 g_AVSessionService->HandleSessionRelease(avsessionItem->GetSessionId());
127 SLOGI("SetDeviceInfo001 end!");
128 }
129
130 /**
131 * @tc.name: GetAudioDescriptorByDeviceId001
132 * @tc.desc: Test GetAudioDescriptorByDeviceId
133 * @tc.type: FUNC
134 */
135 static HWTEST_F(AVSessionServiceSupplementTest, GetAudioDescriptorByDeviceId001, TestSize.Level0)
136 {
137 SLOGI("GetAudioDescriptorByDeviceId001 begin!");
138 std::vector<std::shared_ptr<AudioStandard::AudioDeviceDescriptor>> descriptors;
139 std::shared_ptr<AudioStandard::AudioDeviceDescriptor> descriptor =
140 std::make_shared<AudioStandard::AudioDeviceDescriptor>();
141 descriptors.push_back(descriptor);
142 std::string deviceId = "0";
143 AudioStandard::AudioDeviceDescriptor audioDescriptor;
144 bool ret = g_AVSessionService->GetAudioDescriptorByDeviceId(descriptors, deviceId, audioDescriptor);
145 EXPECT_EQ(ret, true);
146 SLOGI("GetAudioDescriptorByDeviceId001 end!");
147 }
148
149 /**
150 * @tc.name: GetAudioDescriptorByDeviceId002
151 * @tc.desc: Test GetAudioDescriptorByDeviceId
152 * @tc.type: FUNC
153 */
154 static HWTEST_F(AVSessionServiceSupplementTest, GetAudioDescriptorByDeviceId002, TestSize.Level0)
155 {
156 SLOGI("GetAudioDescriptorByDeviceId002 begin!");
157 std::vector<std::shared_ptr<AudioStandard::AudioDeviceDescriptor>> descriptors;
158 std::shared_ptr<AudioStandard::AudioDeviceDescriptor> descriptor =
159 std::make_shared<AudioStandard::AudioDeviceDescriptor>();
160 descriptors.push_back(descriptor);
161 std::string deviceId = "1";
162 AudioStandard::AudioDeviceDescriptor audioDescriptor;
163 bool ret = g_AVSessionService->GetAudioDescriptorByDeviceId(descriptors, deviceId, audioDescriptor);
164 EXPECT_EQ(ret, false);
165 SLOGI("GetAudioDescriptorByDeviceId002 end!");
166 }
167
168 /**
169 * @tc.name: GetDeviceInfo001
170 * @tc.desc: Test GetDeviceInfo
171 * @tc.type: FUNC
172 */
173 static HWTEST_F(AVSessionServiceSupplementTest, GetDeviceInfo001, TestSize.Level0)
174 {
175 SLOGI("GetDeviceInfo001 begin!");
176 OHOS::AppExecFwk::ElementName elementName;
177 elementName.SetBundleName(g_testAnotherBundleName);
178 elementName.SetAbilityName(g_testAnotherAbilityName);
179 sptr<AVSessionItem> avsessionItem = g_AVSessionService->CreateSessionInner(
180 g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
181
182 std::vector<AudioStandard::AudioDeviceDescriptor> castSinkDescriptors;
183 std::vector<AudioStandard::AudioDeviceDescriptor> cancelSinkDescriptors;
184 std::vector<AudioStandard::AudioDeviceDescriptor> descriptors;
185 AudioStandard::AudioDeviceDescriptor descriptor;
186 descriptors.push_back(descriptor);
187
188 g_AVSessionService->GetDeviceInfo(avsessionItem,
189 descriptors, castSinkDescriptors, cancelSinkDescriptors);
190 EXPECT_EQ(castSinkDescriptors.size(), descriptors.size());
191 avsessionItem->Destroy();
192 g_AVSessionService->HandleSessionRelease(avsessionItem->GetSessionId());
193 SLOGI("GetDeviceInfo001 end!");
194 }
195
196 /**
197 * @tc.name: GetDeviceInfo002
198 * @tc.desc: Test GetDeviceInfo
199 * @tc.type: FUNC
200 */
201 static HWTEST_F(AVSessionServiceSupplementTest, GetDeviceInfo002, TestSize.Level0)
202 {
203 SLOGI("GetDeviceInfo002 begin!");
204 OHOS::AppExecFwk::ElementName elementName;
205 elementName.SetBundleName(g_testAnotherBundleName);
206 elementName.SetAbilityName(g_testAnotherAbilityName);
207 sptr<AVSessionItem> avsessionItem = g_AVSessionService->CreateSessionInner(
208 g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
209
210 std::vector<AudioStandard::AudioDeviceDescriptor> castSinkDescriptors;
211 std::vector<AudioStandard::AudioDeviceDescriptor> cancelSinkDescriptors;
212 std::vector<AudioStandard::AudioDeviceDescriptor> descriptors;
213
214 g_AVSessionService->GetDeviceInfo(avsessionItem,
215 descriptors, castSinkDescriptors, cancelSinkDescriptors);
216 EXPECT_EQ(descriptors.size(), 0);
217 avsessionItem->Destroy();
218 g_AVSessionService->HandleSessionRelease(avsessionItem->GetSessionId());
219 SLOGI("GetDeviceInfo002 end!");
220 }
221
222 /**
223 * @tc.name: CastAudioProcess001
224 * @tc.desc: Test CastAudioProcess
225 * @tc.type: FUNC
226 */
227 static HWTEST_F(AVSessionServiceSupplementTest, CastAudioProcess001, TestSize.Level0)
228 {
229 SLOGI("CastAudioProcess001 begin!");
230 OHOS::AppExecFwk::ElementName elementName;
231 elementName.SetBundleName(g_testAnotherBundleName);
232 elementName.SetAbilityName(g_testAnotherAbilityName);
233 sptr<AVSessionItem> avsessionItem = g_AVSessionService->CreateSessionInner(
234 g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
235
236 std::vector<AudioStandard::AudioDeviceDescriptor> descriptors;
237 AudioStandard::AudioDeviceDescriptor descriptor;
238 descriptors.push_back(descriptor);
239
240 std::string sourceSessionInfo = "";
241 int32_t ret = g_AVSessionService->CastAudioProcess(descriptors,
242 sourceSessionInfo, avsessionItem);
243 EXPECT_EQ(ret, AVSESSION_ERROR);
244 avsessionItem->Destroy();
245 g_AVSessionService->HandleSessionRelease(avsessionItem->GetSessionId());
246 SLOGI("CastAudioProcess001 end!");
247 }
248
249 /**
250 * @tc.name: CastAudioProcess002
251 * @tc.desc: Test CastAudioProcess
252 * @tc.type: FUNC
253 */
254 static HWTEST_F(AVSessionServiceSupplementTest, CastAudioProcess002, TestSize.Level0)
255 {
256 SLOGI("CastAudioProcess002 begin!");
257 OHOS::AppExecFwk::ElementName elementName;
258 elementName.SetBundleName(g_testAnotherBundleName);
259 elementName.SetAbilityName(g_testAnotherAbilityName);
260 sptr<AVSessionItem> avsessionItem = g_AVSessionService->CreateSessionInner(
261 g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
262
263 AudioStandard::AudioDeviceDescriptor descriptor;
264 std::vector<AudioStandard::AudioDeviceDescriptor> setDescriptors;
265 setDescriptors.push_back(descriptor);
266 g_AVSessionService->SetDeviceInfo(setDescriptors, avsessionItem);
267
268 std::string sourceSessionInfo = "";
269 int32_t ret = g_AVSessionService->CastAudioProcess(setDescriptors,
270 sourceSessionInfo, avsessionItem);
271 EXPECT_EQ(ret, AVSESSION_ERROR);
272 avsessionItem->Destroy();
273 g_AVSessionService->HandleSessionRelease(avsessionItem->GetSessionId());
274 SLOGI("CastAudioProcess002 end!");
275 }
276
277 /**
278 * @tc.name: IsHistoricalSession001
279 * @tc.desc: Test IsHistoricalSession
280 * @tc.type: FUNC
281 */
282 static HWTEST_F(AVSessionServiceSupplementTest, IsHistoricalSession001, TestSize.Level0)
283 {
284 SLOGI("IsHistoricalSession001 begin!");
285 OHOS::AppExecFwk::ElementName elementName;
286 elementName.SetBundleName(g_testAnotherBundleName);
287 elementName.SetAbilityName(g_testAnotherAbilityName);
288 sptr<AVSessionItem> avsessionItem = g_AVSessionService->CreateSessionInner(
289 g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
290
291 std::string id = "*****";
292 std::string filePath = g_AVSessionService->GetAVSortDir();
293 std::ofstream ofs;
294 ofs.open(filePath, std::ios::out);
295 ofs << id;
296 ofs.close();
297
298 bool ret = g_AVSessionService->IsHistoricalSession(id);
299 EXPECT_EQ(ret, true);
300 avsessionItem->Destroy();
301 g_AVSessionService->HandleSessionRelease(avsessionItem->GetSessionId());
302 SLOGI("IsHistoricalSession001 end!");
303 }
304
305 /**
306 * @tc.name: IsHistoricalSession002
307 * @tc.desc: Test IsHistoricalSession
308 * @tc.type: FUNC
309 */
310 static HWTEST_F(AVSessionServiceSupplementTest, IsHistoricalSession002, TestSize.Level0)
311 {
312 SLOGI("IsHistoricalSession002 begin!");
313 OHOS::AppExecFwk::ElementName elementName;
314 elementName.SetBundleName(g_testAnotherBundleName);
315 elementName.SetAbilityName(g_testAnotherAbilityName);
316 sptr<AVSessionItem> avsessionItem = g_AVSessionService->CreateSessionInner(
317 g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
318
319 std::string sessionId = avsessionItem->GetSessionId();
320 std::string filePath = g_AVSessionService->GetAVSortDir();
321 std::ofstream ofs;
322 ofs.open(filePath, std::ios::out);
323 ofs << sessionId;
324 ofs.close();
325
326 bool ret = g_AVSessionService->IsHistoricalSession(sessionId);
327 EXPECT_EQ(ret, false);
328 avsessionItem->Destroy();
329 g_AVSessionService->HandleSessionRelease(avsessionItem->GetSessionId());
330 SLOGI("IsHistoricalSession002 end!");
331 }
332
333 /**
334 * @tc.name: Dump001
335 * @tc.desc: Test Dump
336 * @tc.type: FUNC
337 */
338 static HWTEST_F(AVSessionServiceSupplementTest, Dump001, TestSize.Level0)
339 {
340 SLOGI("Dump001 with OnStartProcess begin!");
341 std::vector<std::u16string> argsList;
342 g_AVSessionService->dumpHelper_ = std::make_unique<AVSessionDumper>();
343 int32_t ret = g_AVSessionService->Dump(1, argsList);
344 EXPECT_EQ(ret, AVSESSION_SUCCESS);
345 SLOGI("Dump001 end!");
346 }
347
348 /**
349 * @tc.name: Dump002
350 * @tc.desc: Test Dump
351 * @tc.type: FUNC
352 */
353 static HWTEST_F(AVSessionServiceSupplementTest, Dump002, TestSize.Level0)
354 {
355 SLOGI("Dump002 with OnStartProcess begin!");
356 std::vector<std::u16string> argsList;
357 std::u16string str(5, 'a');
358 argsList.emplace_back(str);
359 g_AVSessionService->dumpHelper_ = std::make_unique<AVSessionDumper>();
360 int32_t ret = g_AVSessionService->Dump(1, argsList);
361 EXPECT_EQ(ret, AVSESSION_SUCCESS);
362 SLOGI("Dump002 end!");
363 }
364
365 /**
366 * @tc.name: SaveStringToFileEx001
367 * @tc.desc: Test SaveStringToFile
368 * @tc.type: FUNC
369 */
370 static HWTEST_F(AVSessionServiceSupplementTest, SaveStringToFileEx001, TestSize.Level0)
371 {
372 SLOGI("SaveStringToFileEx001 begin!");
373 OHOS::AppExecFwk::ElementName elementName;
374 elementName.SetBundleName(g_testAnotherBundleName);
375 elementName.SetAbilityName(g_testAnotherAbilityName);
376 sptr<AVSessionItem> avsessionItem = g_AVSessionService->CreateSessionInner(
377 g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
378
379 std::string filePath = "/adcdXYZ123/test5.txt";
380 std::string content;
381 std::ifstream file(filePath, std::ios_base::in);
382 bool ret = g_AVSessionService->SaveStringToFileEx(filePath, content);
383 file.close();
384 EXPECT_EQ(ret, false);
385 avsessionItem->Destroy();
386 g_AVSessionService->HandleSessionRelease(avsessionItem->GetSessionId());
387 SLOGI("SaveStringToFileEx001 end!");
388 }
389
390 /**
391 * @tc.name: SaveStringToFileEx002
392 * @tc.desc: Test SaveStringToFile
393 * @tc.type: FUNC
394 */
395 static HWTEST_F(AVSessionServiceSupplementTest, SaveStringToFileEx002, TestSize.Level0)
396 {
397 SLOGI("SaveStringToFileEx002 begin!");
398 OHOS::AppExecFwk::ElementName elementName;
399 elementName.SetBundleName(g_testAnotherBundleName);
400 elementName.SetAbilityName(g_testAnotherAbilityName);
401 sptr<AVSessionItem> avsessionItem = g_AVSessionService->CreateSessionInner(
402 g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
403
404 std::string filePath = g_AVSessionService->GetAVSortDir();
405 std::string content;
406 bool ret = g_AVSessionService->SaveStringToFileEx(filePath, content);
407 EXPECT_EQ(ret, false);
408 avsessionItem->Destroy();
409 g_AVSessionService->HandleSessionRelease(avsessionItem->GetSessionId());
410 SLOGI("SaveStringToFileEx002 end!");
411 }
412
413 /**
414 * @tc.name: SaveStringToFileEx003
415 * @tc.desc: Test SaveStringToFile
416 * @tc.type: FUNC
417 */
418 static HWTEST_F(AVSessionServiceSupplementTest, SaveStringToFileEx003, TestSize.Level0)
419 {
420 SLOGI("SaveStringToFileEx003 begin!");
421 OHOS::AppExecFwk::ElementName elementName;
422 elementName.SetBundleName(g_testAnotherBundleName);
423 elementName.SetAbilityName(g_testAnotherAbilityName);
424 sptr<AVSessionItem> avsessionItem = g_AVSessionService->CreateSessionInner(
425 g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
426
427 std::string filePath = g_AVSessionService->GetAVSortDir();
428 std::string content = "123456";
429 bool ret = g_AVSessionService->SaveStringToFileEx(filePath, content);
430 EXPECT_EQ(ret, true);
431 avsessionItem->Destroy();
432 g_AVSessionService->HandleSessionRelease(avsessionItem->GetSessionId());
433 SLOGI("SaveStringToFileEx003 end!");
434 }
435
436 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
437 /**
438 * @tc.name: SuperLauncher001
439 * @tc.desc: Test SuperLauncher
440 * @tc.type: FUNC
441 */
442 static HWTEST_F(AVSessionServiceSupplementTest, SuperLauncher001, TestSize.Level0)
443 {
444 SLOGI("SuperLauncher001 begin!");
445 std::string devideId = "***";
446 std::string extraInfo = "*,**";
447 std::vector< std::string > serviceNames = {"HuaweiCast", "HuaweiCast-Dual"};
448 std::vector< std::string > states = {"IDLE", "CONNECT_SUCC"};
449 for (std::string serviceName : serviceNames) {
450 for (std::string state : states) {
451 g_AVSessionService->SuperLauncher(devideId, serviceName, extraInfo, state);
452 }
453 }
454
455 EXPECT_EQ(serviceNames.size(), 2);
456 SLOGI("SuperLauncher001 end!");
457 }
458
459 /**
460 * @tc.name: SuperLauncher002
461 * @tc.desc: Test SuperLauncher
462 * @tc.type: FUNC
463 */
464 static HWTEST_F(AVSessionServiceSupplementTest, SuperLauncher002, TestSize.Level0)
465 {
466 SLOGI("SuperLauncher002 begin!");
467 std::string devideId = "***";
468 std::string extraInfo = "***";
469 std::string serviceName = "***";
470 std::string state = "***";
471 g_AVSessionService->SuperLauncher(devideId, serviceName, extraInfo, state);
472 EXPECT_EQ(serviceName, "***");
473 SLOGI("SuperLauncher002 end!");
474 }
475
476 /**
477 * @tc.name: SplitExtraInfo001
478 * @tc.desc: Test SplitExtraInfo
479 * @tc.type: FUNC
480 */
481 static HWTEST_F(AVSessionServiceSupplementTest, SplitExtraInfo001, TestSize.Level0)
482 {
483 SLOGI("SplitExtraInfo001 begin!");
484 std::string info = R"(
485 {SUPPORT_MIRROR_TO_STREAM: true},
486 {deviceId: ***},
487 {deviceName: ***},
488 {deviceType: ***}
489 )";
490 g_AVSessionService->SplitExtraInfo(info);
491 EXPECT_NE(info.size(), 0);
492 SLOGI("SplitExtraInfo001 end!");
493 }
494
495 /**
496 * @tc.name: SplitExtraInfo002
497 * @tc.desc: Test SplitExtraInfo
498 * @tc.type: FUNC
499 */
500 static HWTEST_F(AVSessionServiceSupplementTest, SplitExtraInfo002, TestSize.Level0)
501 {
502 SLOGI("SplitExtraInfo002 begin!");
503 std::string info = R"(
504 {SUPPORT_MIRROR_TO_STREAM, false},
505 {deviceId, ***},
506 {deviceName, ***},
507 {deviceType, ***}
508 )";
509 g_AVSessionService->SplitExtraInfo(info);
510 EXPECT_NE(info.size(), 0);
511 SLOGI("SplitExtraInfo002 end!");
512 }
513
514 /**
515 * @tc.name: SplitExtraInfo003
516 * @tc.desc: Test SplitExtraInfo
517 * @tc.type: FUNC
518 */
519 static HWTEST_F(AVSessionServiceSupplementTest, SplitExtraInfo003, TestSize.Level0)
520 {
521 SLOGI("SplitExtraInfo003 begin!");
522 std::string info = "";
523 g_AVSessionService->SplitExtraInfo(info);
524 EXPECT_EQ(info.size(), 0);
525 SLOGI("SplitExtraInfo003 end!");
526 }
527
528 #endif
529 } // OHOS::AVSession