1 /*
2 * Copyright (c) 2022-2025 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 "avsession_manager.h"
19 #include "avsession_errors.h"
20 #include "avsession_callback_client.h"
21 #include "want_agent.h"
22 #include "avmeta_data.h"
23 #include "avplayback_state.h"
24 #include "avcall_state.h"
25 #include "avcall_meta_data.h"
26 #include "avmedia_description.h"
27 #include "avqueue_item.h"
28 #include "avsession_log.h"
29 #include "avcontrol_command.h"
30
31 #include "accesstoken_kit.h"
32 #include "bool_wrapper.h"
33 #include "nativetoken_kit.h"
34 #include "token_setproc.h"
35
36 using namespace testing::ext;
37 using namespace OHOS::Security::AccessToken;
38
39 namespace OHOS {
40 namespace AVSession {
41 static int32_t g_onCall = AVSESSION_ERROR;
42 static int32_t g_sessionId = AVSESSION_ERROR;
43 static AVMetaData g_metaData;
44 static AVCallMetaData g_avCallMetaData;
45 static AVCallState g_avCallState;
46 static AVPlaybackState g_playbackState;
47 static char g_testSessionTag[] = "test";
48 static char g_testBundleName[] = "test.ohos.avsession";
49 static char g_testAbilityName[] = "test.ability";
50 static uint64_t g_selfTokenId = 0;
51
52 static HapInfoParams g_info = {
53 .userID = 100,
54 .bundleName = "ohos.permission_test.demo",
55 .instIndex = 0,
56 .appIDDesc = "ohos.permission_test.demo",
57 .isSystemApp = true
58 };
59
60 static HapPolicyParams g_policy = {
61 .apl = APL_NORMAL,
62 .domain = "test.domain",
63 .permList = {
64 {
65 .permissionName = "ohos.permission.MANAGE_MEDIA_RESOURCES",
66 .bundleName = "ohos.permission_test.demo",
67 .grantMode = 1,
68 .availableLevel = APL_NORMAL,
69 .label = "label",
70 .labelId = 1,
71 .description = "test",
72 .descriptionId = 1
73 }
74 },
75 .permStateList = {
76 {
77 .permissionName = "ohos.permission.MANAGE_MEDIA_RESOURCES",
78 .isGeneral = true,
79 .resDeviceID = { "local" },
80 .grantStatus = { PermissionState::PERMISSION_GRANTED },
81 .grantFlags = { 1 }
82 }
83 }
84 };
85
86 class AvsessionTest : public testing::Test {
87 public:
88 static void SetUpTestCase();
89 static void TearDownTestCase();
90 void SetUp() override;
91 void TearDown() override;
92
93 std::shared_ptr<AVSession> avsession_ = nullptr;
94 std::shared_ptr<AVSessionController> controller_ = nullptr;
95
96 static constexpr int SESSION_LEN = 64;
97 };
98
SetUpTestCase()99 void AvsessionTest::SetUpTestCase()
100 {
101 g_selfTokenId = GetSelfTokenID();
102 AccessTokenKit::AllocHapToken(g_info, g_policy);
103 AccessTokenIDEx tokenID = AccessTokenKit::GetHapTokenIDEx(g_info.userID, g_info.bundleName, g_info.instIndex);
104 SetSelfTokenID(tokenID.tokenIDEx);
105 }
106
TearDownTestCase()107 void AvsessionTest::TearDownTestCase()
108 {
109 SetSelfTokenID(g_selfTokenId);
110 auto tokenId = AccessTokenKit::GetHapTokenID(g_info.userID, g_info.bundleName, g_info.instIndex);
111 AccessTokenKit::DeleteToken(tokenId);
112 }
113
SetUp()114 void AvsessionTest::SetUp()
115 {
116 OHOS::AppExecFwk::ElementName elementName;
117 elementName.SetBundleName(g_testBundleName);
118 elementName.SetAbilityName(g_testAbilityName);
119 avsession_ = AVSessionManager::GetInstance().CreateSession(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO,
120 elementName);
121 ASSERT_NE(avsession_, nullptr);
122 g_sessionId++;
123 auto ret = AVSessionManager::GetInstance().CreateController(avsession_->GetSessionId(), controller_);
124 ASSERT_EQ(ret, AVSESSION_SUCCESS);
125 ASSERT_NE(controller_, nullptr);
126 }
127
TearDown()128 void AvsessionTest::TearDown()
129 {
130 [[maybe_unused]] int32_t ret = AVSESSION_ERROR;
131 if (avsession_ != nullptr) {
132 ret = avsession_->Destroy();
133 avsession_ = nullptr;
134 }
135 if (controller_ != nullptr) {
136 ret = controller_->Destroy();
137 controller_ = nullptr;
138 }
139 g_onCall = AVSESSION_ERROR;
140 }
141
142 class AVSessionDemo : public AVSession {
143 public:
144 std::string GetSessionId() override;
145 std::string GetSessionType() override;
146 int32_t GetAVMetaData(AVMetaData& meta) override;
147 int32_t SetAVMetaData(const AVMetaData& meta) override;
148 int32_t SetAVCallMetaData(const AVCallMetaData& meta) override;
149 int32_t SetAVCallState(const AVCallState& avCallState) override;
150 int32_t GetAVPlaybackState(AVPlaybackState& state) override;
151 int32_t SetAVPlaybackState(const AVPlaybackState& state) override;
152 int32_t GetAVQueueItems(std::vector<AVQueueItem>& items) override;
153 int32_t SetAVQueueItems(const std::vector<AVQueueItem>& items) override;
154 int32_t GetAVQueueTitle(std::string& title) override;
155 int32_t SetAVQueueTitle(const std::string& title) override;
156 int32_t SetLaunchAbility(const AbilityRuntime::WantAgent::WantAgent& ability) override;
157 int32_t GetExtras(AAFwk::WantParams& extras) override;
158 int32_t SetExtras(const AAFwk::WantParams& extras) override;
159 std::shared_ptr<AVSessionController> GetController() override;
160 int32_t RegisterCallback(const std::shared_ptr<AVSessionCallback>& callback) override;
161 int32_t Activate() override;
162 int32_t Deactivate() override;
163 bool IsActive() override;
164 int32_t Destroy() override;
165 int32_t AddSupportCommand(const int32_t cmd) override;
166 int32_t DeleteSupportCommand(const int32_t cmd) override;
167 int32_t SetSessionEvent(const std::string& event, const AAFwk::WantParams& args) override;
168 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
169 std::shared_ptr<AVCastController> GetAVCastController() override;
170 int32_t ReleaseCast(bool continuePlay = false) override;
171 int32_t StartCastDisplayListener() override;
172 int32_t StopCastDisplayListener() override;
173 int32_t GetAllCastDisplays(std::vector<CastDisplayInfo>& castDisplays) override;
174 #endif
175 };
176
GetSessionId()177 std::string AVSessionDemo::GetSessionId()
178 {
179 return "";
180 }
181
GetSessionType()182 std::string AVSessionDemo::GetSessionType()
183 {
184 return "";
185 }
186
GetAVMetaData(AVMetaData & meta)187 int32_t AVSessionDemo::GetAVMetaData(AVMetaData& meta)
188 {
189 return 0;
190 }
191
SetAVMetaData(const AVMetaData & meta)192 int32_t AVSessionDemo::SetAVMetaData(const AVMetaData& meta)
193 {
194 return 0;
195 }
196
SetAVCallMetaData(const AVCallMetaData & meta)197 int32_t AVSessionDemo::SetAVCallMetaData(const AVCallMetaData& meta)
198 {
199 return 0;
200 }
201
SetAVCallState(const AVCallState & avCallState)202 int32_t AVSessionDemo::SetAVCallState(const AVCallState& avCallState)
203 {
204 return 0;
205 }
206
GetAVPlaybackState(AVPlaybackState & state)207 int32_t AVSessionDemo::GetAVPlaybackState(AVPlaybackState& state)
208 {
209 return 0;
210 }
211
SetAVPlaybackState(const AVPlaybackState & state)212 int32_t AVSessionDemo::SetAVPlaybackState(const AVPlaybackState& state)
213 {
214 return 0;
215 }
216
GetAVQueueItems(std::vector<AVQueueItem> & items)217 int32_t AVSessionDemo::GetAVQueueItems(std::vector<AVQueueItem>& items)
218 {
219 return 0;
220 }
221
SetAVQueueItems(const std::vector<AVQueueItem> & items)222 int32_t AVSessionDemo::SetAVQueueItems(const std::vector<AVQueueItem>& items)
223 {
224 return 0;
225 }
226
GetAVQueueTitle(std::string & title)227 int32_t AVSessionDemo::GetAVQueueTitle(std::string& title)
228 {
229 return 0;
230 }
231
SetAVQueueTitle(const std::string & title)232 int32_t AVSessionDemo::SetAVQueueTitle(const std::string& title)
233 {
234 return 0;
235 }
236
SetLaunchAbility(const AbilityRuntime::WantAgent::WantAgent & ability)237 int32_t AVSessionDemo::SetLaunchAbility(const AbilityRuntime::WantAgent::WantAgent& ability)
238 {
239 return 0;
240 }
241
GetExtras(AAFwk::WantParams & extras)242 int32_t AVSessionDemo::GetExtras(AAFwk::WantParams& extras)
243 {
244 return 0;
245 }
246
SetExtras(const AAFwk::WantParams & extras)247 int32_t AVSessionDemo::SetExtras(const AAFwk::WantParams& extras)
248 {
249 return 0;
250 }
251
GetController()252 std::shared_ptr<AVSessionController> AVSessionDemo::GetController()
253 {
254 return nullptr;
255 }
256
RegisterCallback(const std::shared_ptr<AVSessionCallback> & callback)257 int32_t AVSessionDemo::RegisterCallback(const std::shared_ptr<AVSessionCallback>& callback)
258 {
259 return 0;
260 }
261
Activate()262 int32_t AVSessionDemo::Activate()
263 {
264 return 0;
265 }
266
Deactivate()267 int32_t AVSessionDemo::Deactivate()
268 {
269 return 0;
270 }
271
IsActive()272 bool AVSessionDemo::IsActive()
273 {
274 return false;
275 }
276
Destroy()277 int32_t AVSessionDemo::Destroy()
278 {
279 return 0;
280 }
281
AddSupportCommand(const int32_t cmd)282 int32_t AVSessionDemo::AddSupportCommand(const int32_t cmd)
283 {
284 return 0;
285 }
286
DeleteSupportCommand(const int32_t cmd)287 int32_t AVSessionDemo::DeleteSupportCommand(const int32_t cmd)
288 {
289 return 0;
290 }
291
SetSessionEvent(const std::string & event,const AAFwk::WantParams & args)292 int32_t AVSessionDemo::SetSessionEvent(const std::string& event, const AAFwk::WantParams& args)
293 {
294 return 0;
295 }
296
297 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
GetAVCastController()298 std::shared_ptr<AVCastController> AVSessionDemo::GetAVCastController()
299 {
300 return nullptr;
301 }
302
ReleaseCast(bool continuePlay=false)303 int32_t AVSessionDemo::ReleaseCast(bool continuePlay = false)
304 {
305 return 0;
306 }
307
StartCastDisplayListener()308 int32_t AVSessionDemo::StartCastDisplayListener()
309 {
310 return 0;
311 }
312
StopCastDisplayListener()313 int32_t AVSessionDemo::StopCastDisplayListener()
314 {
315 return 0;
316 }
317
GetAllCastDisplays(std::vector<CastDisplayInfo> & castDisplays)318 int32_t AVSessionDemo::GetAllCastDisplays(std::vector<CastDisplayInfo>& castDisplays)
319 {
320 return 0;
321 }
322 #endif
323
324 class AVSessionCallbackImpl : public AVSessionCallback {
325 public:
326 void OnPlay() override;
327 void OnPause() override;
328 void OnStop() override;
329 void OnPlayNext() override;
330 void OnPlayPrevious() override;
331 void OnFastForward(int64_t time) override;
332 void OnRewind(int64_t time) override;
333 void OnSeek(int64_t time) override;
334 void OnSetSpeed(double speed) override;
335 void OnSetLoopMode(int32_t loopMode) override;
336 void OnSetTargetLoopMode(int32_t targetLoopMode) override;
337 void OnToggleFavorite(const std::string& mediaId) override;
338 void OnMediaKeyEvent(const OHOS::MMI::KeyEvent& keyEvent) override;
OnOutputDeviceChange(const int32_t connectionState,const OHOS::AVSession::OutputDeviceInfo & outputDeviceInfo)339 void OnOutputDeviceChange(const int32_t connectionState,
340 const OHOS::AVSession::OutputDeviceInfo& outputDeviceInfo) override {};
341 void OnCommonCommand(const std::string& commonCommand, const OHOS::AAFwk::WantParams& commandArgs) override;
OnSkipToQueueItem(int32_t itemId)342 void OnSkipToQueueItem(int32_t itemId) override {};
OnAVCallAnswer()343 void OnAVCallAnswer() override {};
OnAVCallHangUp()344 void OnAVCallHangUp() override {};
OnAVCallToggleCallMute()345 void OnAVCallToggleCallMute() override {};
346 void OnPlayFromAssetId(int64_t assetId) override;
347 void OnPlayWithAssetId(const std::string& assetId) override;
348 void OnCastDisplayChange(const CastDisplayInfo& castDisplayInfo) override;
349
350 ~AVSessionCallbackImpl() override;
351 };
352
OnPlay()353 void AVSessionCallbackImpl::OnPlay()
354 {
355 g_onCall = AVSESSION_SUCCESS;
356 SLOGE("OnPlay %{public}d", g_onCall);
357 }
358
OnPause()359 void AVSessionCallbackImpl::OnPause()
360 {
361 g_onCall = AVSESSION_SUCCESS;
362 SLOGE("OnPause %{public}d", g_onCall);
363 }
364
OnStop()365 void AVSessionCallbackImpl::OnStop()
366 {
367 g_onCall = AVSESSION_SUCCESS;
368 SLOGE("OnStop %{public}d", g_onCall);
369 }
370
OnPlayNext()371 void AVSessionCallbackImpl::OnPlayNext()
372 {
373 g_onCall = AVSESSION_SUCCESS;
374 SLOGE("OnPlayNext %{public}d", g_onCall);
375 }
376
OnPlayPrevious()377 void AVSessionCallbackImpl::OnPlayPrevious()
378 {
379 g_onCall = AVSESSION_SUCCESS;
380 SLOGE("OnPlayPrevious %{public}d", g_onCall);
381 }
382
OnFastForward(int64_t time)383 void AVSessionCallbackImpl::OnFastForward(int64_t time)
384 {
385 g_onCall = AVSESSION_SUCCESS;
386 SLOGE("OnFastForward %{public}d", g_onCall);
387 }
388
OnRewind(int64_t time)389 void AVSessionCallbackImpl::OnRewind(int64_t time)
390 {
391 g_onCall = AVSESSION_SUCCESS;
392 SLOGE("OnRewind %{public}d", g_onCall);
393 }
394
OnSeek(int64_t time)395 void AVSessionCallbackImpl::OnSeek(int64_t time)
396 {
397 SLOGE("OnSeek %{public}" PRId64, time);
398 g_onCall = AVSESSION_SUCCESS;
399 }
400
OnSetSpeed(double speed)401 void AVSessionCallbackImpl::OnSetSpeed(double speed)
402 {
403 SLOGE("OnSetSpeed %{public}f", speed);
404 g_onCall = AVSESSION_SUCCESS;
405 SLOGE("OnSetSpeed %{public}d", g_onCall);
406 }
407
OnSetLoopMode(int32_t loopMode)408 void AVSessionCallbackImpl::OnSetLoopMode(int32_t loopMode)
409 {
410 SLOGE("OnSetLoopMode %{public}d", loopMode);
411 g_onCall = AVSESSION_SUCCESS;
412 SLOGE("OnSetLoopMode %{public}d", g_onCall);
413 }
414
OnSetTargetLoopMode(int32_t targetLoopMode)415 void AVSessionCallbackImpl::OnSetTargetLoopMode(int32_t targetLoopMode)
416 {
417 SLOGE("OnSetTargetLoopMode %{public}d", targetLoopMode);
418 g_onCall = AVSESSION_SUCCESS;
419 SLOGE("OnSetTargetLoopMode %{public}d", g_onCall);
420 }
421
OnToggleFavorite(const std::string & mediaId)422 void AVSessionCallbackImpl::OnToggleFavorite(const std::string& mediaId)
423 {
424 SLOGE("OnToggleFavorite %{public}s", mediaId.c_str());
425 g_onCall = AVSESSION_SUCCESS;
426 SLOGE("OnToggleFavorite %{public}d", g_onCall);
427 }
428
OnMediaKeyEvent(const OHOS::MMI::KeyEvent & keyEvent)429 void AVSessionCallbackImpl::OnMediaKeyEvent(const OHOS::MMI::KeyEvent& keyEvent)
430 {
431 SLOGE("OnMediaKeyEvent");
432 g_onCall = AVSESSION_SUCCESS;
433 }
434
OnCommonCommand(const std::string & commonCommand,const OHOS::AAFwk::WantParams & commandArgs)435 void AVSessionCallbackImpl::OnCommonCommand(const std::string& commonCommand,
436 const OHOS::AAFwk::WantParams& commandArgs)
437 {
438 SLOGI("OnCommonCommand");
439 g_onCall = AVSESSION_SUCCESS;
440 }
441
OnPlayFromAssetId(int64_t assetId)442 void AVSessionCallbackImpl::OnPlayFromAssetId(int64_t assetId)
443 {
444 g_onCall = AVSESSION_SUCCESS;
445 SLOGE("OnPlayFromAssetId %{public}d", g_onCall);
446 }
447
OnPlayWithAssetId(const std::string & assetId)448 void AVSessionCallbackImpl::OnPlayWithAssetId(const std::string& assetId)
449 {
450 g_onCall = AVSESSION_SUCCESS;
451 SLOGE("OnPlayWithAssetId %{public}d", g_onCall);
452 }
453
OnCastDisplayChange(const CastDisplayInfo & castDisplayInfo)454 void AVSessionCallbackImpl::OnCastDisplayChange(const CastDisplayInfo& castDisplayInfo)
455 {
456 SLOGE("OnCastDisplayChange");
457 g_onCall = AVSESSION_SUCCESS;
458 }
459
~AVSessionCallbackImpl()460 AVSessionCallbackImpl::~AVSessionCallbackImpl()
461 {
462 }
463
464 /**
465 * @tc.name: SetAVCallMetaData001
466 * @tc.desc: Return the result of set avcall meta data
467 * @tc.type: FUNC
468 */
469 HWTEST_F(AvsessionTest, SetAVCallMetaData001, TestSize.Level1)
470 {
471 SLOGE("SetAVCallMetaData001 Begin");
472 g_avCallMetaData.Reset();
473 g_avCallMetaData.SetName("");
474 g_avCallMetaData.SetPhoneNumber("123456789");
475
476 EXPECT_EQ(avsession_->SetAVCallMetaData(g_avCallMetaData), AVSESSION_SUCCESS);
477 SLOGE("SetAVCallMetaData001 enable optional params End");
478 }
479
480 /**
481 * @tc.name: SetAVCallMetaData002
482 * @tc.desc: Return the result of set avcall meta data
483 * @tc.type: FUNC
484 */
485 HWTEST_F(AvsessionTest, SetAVCallMetaData002, TestSize.Level1)
486 {
487 SLOGE("SetAVCallMetaData002 Begin");
488 g_avCallMetaData.Reset();
489 g_avCallMetaData.SetName("xiaoming");
490 g_avCallMetaData.SetPhoneNumber("123456789");
491
492 EXPECT_EQ(avsession_->SetAVCallMetaData(g_avCallMetaData), AVSESSION_SUCCESS);
493 SLOGE("SetAVCallMetaData002 End");
494 }
495
496 /**
497 * @tc.name: SetAVCallState001
498 * @tc.desc: Return the result of set avcall meta data
499 * @tc.type: FUNC
500 */
501 HWTEST_F(AvsessionTest, SetAVCallState001, TestSize.Level1)
502 {
503 SLOGE("SetAVCallState001 Begin");
504 g_avCallState.SetAVCallState(2);
505 g_avCallState.SetAVCallMuted(false);
506
507 EXPECT_EQ(avsession_->SetAVCallState(g_avCallState), AVSESSION_SUCCESS);
508 SLOGE("SetAVCallState001 End");
509 }
510
511 /**
512 * @tc.name: GetSessionId001
513 * @tc.desc: Return is Session ID
514 * @tc.type: FUNC
515 * @tc.require: AR000H31JF
516 */
517 HWTEST_F(AvsessionTest, GetSessionId001, TestSize.Level1)
518 {
519 SLOGE("GetSessionId001 Begin");
520 auto sessionId = avsession_->GetSessionId();
521 EXPECT_EQ(sessionId.length() == SESSION_LEN, true);
522 SLOGE("GetSessionId001 End");
523 }
524
525 /**
526 * @tc.name: SetAVMetaData001
527 * @tc.desc: Return the result of set av meta data
528 * @tc.type: FUNC
529 * @tc.require: AR000H31JF
530 */
531 HWTEST_F(AvsessionTest, SetAVMetaData001, TestSize.Level1)
532 {
533 SLOGE("SetAVMetaData001 Begin");
534 g_metaData.Reset();
535 g_metaData.SetAssetId("");
536 g_metaData.SetTitle("Black Humor");
537 g_metaData.SetArtist("zhoujielun");
538 g_metaData.SetAuthor("zhoujielun");
539 g_metaData.SetAlbum("Jay");
540 g_metaData.SetWriter("zhoujielun");
541 g_metaData.SetComposer("zhoujielun");
542 g_metaData.SetDuration(40000);
543 g_metaData.SetMediaImageUri("xxxxx");
544 g_metaData.SetSubTitle("fac");
545 g_metaData.SetDescription("for friends");
546 g_metaData.SetLyric("xxxxx");
547 EXPECT_EQ(avsession_->SetAVMetaData(g_metaData), AVSESSION_ERROR);
548 SLOGE("SetAVMetaData001 End");
549 }
550
551 /**
552 * @tc.name: SetAVMetaData002
553 * @tc.desc: Return the result of set av meta data
554 * @tc.type: FUNC
555 * @tc.require: AR000H31JF
556 */
557 HWTEST_F(AvsessionTest, SetAVMetaData002, TestSize.Level1)
558 {
559 SLOGE("SetAVMetaData002 Begin");
560 g_metaData.Reset();
561 g_metaData.SetAssetId("123");
562 g_metaData.SetTitle("Black Humor");
563 g_metaData.SetArtist("zhoujielun");
564 g_metaData.SetAuthor("zhoujielun");
565 g_metaData.SetAlbum("Jay");
566 g_metaData.SetWriter("zhoujielun");
567 g_metaData.SetComposer("zhoujielun");
568 g_metaData.SetDuration(40000);
569 g_metaData.SetMediaImageUri("xxxxx");
570 g_metaData.SetSubTitle("fac");
571 g_metaData.SetDescription("for friends");
572 g_metaData.SetLyric("xxxxx");
573 EXPECT_EQ(avsession_->SetAVMetaData(g_metaData), AVSESSION_SUCCESS);
574 SLOGE("SetAVMetaData002 End");
575 }
576
577 /**
578 * @tc.name: GetAVMetaData001
579 * @tc.desc: Return get av meta data result
580 * @tc.type: FUNC
581 * @tc.require: AR000H31JF
582 */
583 HWTEST_F(AvsessionTest, GetAVMetaData001, TestSize.Level1)
584 {
585 SLOGE("GetAVMetaData001 Begin");
586 EXPECT_EQ(avsession_->SetAVMetaData(g_metaData), AVSESSION_SUCCESS);
587 AVMetaData metaData;
588 metaData.Reset();
589 EXPECT_EQ(avsession_->GetAVMetaData(metaData), AVSESSION_SUCCESS);
590 EXPECT_EQ(metaData.GetAssetId(), g_metaData.GetAssetId());
591 std::string title1 = metaData.GetTitle();
592 SLOGE("title1 %{public}s", title1.c_str());
593 std::string title2 = g_metaData.GetTitle();
594 SLOGE("title2 %{public}s", title2.c_str());
595 EXPECT_EQ(title1, title2);
596 EXPECT_EQ(metaData.GetTitle(), g_metaData.GetTitle());
597 EXPECT_EQ(metaData.GetArtist(), g_metaData.GetArtist());
598 EXPECT_EQ(metaData.GetAuthor(), g_metaData.GetAuthor());
599 EXPECT_EQ(metaData.GetAlbum(), g_metaData.GetAlbum());
600 EXPECT_EQ(metaData.GetWriter(), g_metaData.GetWriter());
601 EXPECT_EQ(metaData.GetComposer(), g_metaData.GetComposer());
602 EXPECT_EQ(metaData.GetDuration(), g_metaData.GetDuration());
603 EXPECT_EQ(metaData.GetMediaImageUri(), g_metaData.GetMediaImageUri());
604 EXPECT_EQ(metaData.GetSubTitle(), g_metaData.GetSubTitle());
605 EXPECT_EQ(metaData.GetDescription(), g_metaData.GetDescription());
606 EXPECT_EQ(metaData.GetLyric(), g_metaData.GetLyric());
607 SLOGE("GetAVMetaData001 End");
608 }
609
610 /**
611 * @tc.name: SetAVPlaybackState001
612 * @tc.desc: Return the result of set av playback state
613 * @tc.type: FUNC
614 * @tc.require: AR000H31JF
615 */
616 HWTEST_F(AvsessionTest, SetAVPlaybackState001, TestSize.Level1)
617 {
618 SLOGE("SetAVPlaybackState001 Begin");
619 AVMetaData metaData;
620 metaData.Reset();
621 metaData.SetAssetId("playback");
622 metaData.SetDuration(20);
623 EXPECT_EQ(avsession_->SetAVMetaData(metaData), AVSESSION_SUCCESS);
624 g_playbackState.SetState(1);
625 g_playbackState.SetSpeed(1.5);
626 g_playbackState.SetPosition({80000, 0});
627 g_playbackState.SetBufferedTime(60000);
628 g_playbackState.SetLoopMode(2);
629 g_playbackState.SetFavorite(true);
630 EXPECT_EQ(avsession_->SetAVPlaybackState(g_playbackState), AVSESSION_SUCCESS);
631 SLOGE("SetAVPlaybackState001 End");
632 }
633
634 /**
635 * @tc.name: SetAVPlaybackState002
636 * @tc.desc: Return the result of set av playback state
637 * @tc.type: FUNC
638 * @tc.require: AR000H31JF
639 */
640 HWTEST_F(AvsessionTest, SetAVPlaybackState002, TestSize.Level1)
641 {
642 SLOGE("SetAVPlaybackState002 Begin");
643 g_playbackState.SetState(1);
644 g_playbackState.SetSpeed(1);
645 g_playbackState.SetPosition({80000, 0});
646 g_playbackState.SetBufferedTime(700000);
647 g_playbackState.SetLoopMode(1);
648 g_playbackState.SetFavorite(true);
649 EXPECT_EQ(avsession_->SetAVPlaybackState(g_playbackState), AVSESSION_SUCCESS);
650 SLOGE("SetAVPlaybackState002 End");
651 }
652
653 /**
654 * @tc.name: SetAVPlaybackState003
655 * @tc.desc: Return the result of set av playback state
656 * @tc.type: FUNC
657 * @tc.require: AR000H31JF
658 */
659 HWTEST_F(AvsessionTest, SetAVPlaybackState003, TestSize.Level1)
660 {
661 SLOGE("SetAVPlaybackState003 Begin");
662 AVMetaData metaData;
663 metaData.Reset();
664 metaData.SetAssetId("playback");
665 metaData.SetDuration(2000000);
666 EXPECT_EQ(avsession_->SetAVMetaData(metaData), AVSESSION_SUCCESS);
667 g_playbackState.SetState(1);
668 g_playbackState.SetSpeed(1);
669 g_playbackState.SetPosition({80000, 0});
670 g_playbackState.SetBufferedTime(17000);
671 g_playbackState.SetLoopMode(1);
672 g_playbackState.SetFavorite(true);
673 EXPECT_EQ(avsession_->SetAVPlaybackState(g_playbackState), AVSESSION_SUCCESS);
674 SLOGE("SetAVPlaybackState003 End");
675 }
676
677 /**
678 * @tc.name: SetAVPlaybackState004
679 * @tc.desc: Return the result of set av playback state
680 * @tc.type: FUNC
681 * @tc.require: AR000H31JF
682 */
683 HWTEST_F(AvsessionTest, SetAVPlaybackState004, TestSize.Level1)
684 {
685 SLOGE("SetAVPlaybackState004 Begin");
686 AVMetaData metaData;
687 metaData.Reset();
688 metaData.SetAssetId("playback");
689 metaData.SetDuration(2000000);
690 EXPECT_EQ(avsession_->SetAVMetaData(metaData), AVSESSION_SUCCESS);
691 g_playbackState.SetState(1);
692 g_playbackState.SetSpeed(1);
693 g_playbackState.SetPosition({10000, 0});
694 g_playbackState.SetBufferedTime(17000);
695 g_playbackState.SetLoopMode(1);
696 g_playbackState.SetFavorite(true);
697 EXPECT_EQ(avsession_->SetAVPlaybackState(g_playbackState), AVSESSION_SUCCESS);
698 SLOGE("SetAVPlaybackState004 End");
699 }
700
701 /**
702 * @tc.name: SetSessionEventTest001
703 * @tc.desc: Set session event
704 * @tc.type: FUNC
705 * @tc.require: I6C6IN
706 */
707 HWTEST_F(AvsessionTest, SetSessionEventTest001, TestSize.Level1)
708 {
709 SLOGE("SetSessionEventTest001 Begin");
710 std::string event = "eventName";
711 OHOS::AAFwk::WantParams args;
712 EXPECT_EQ(avsession_->SetSessionEvent(event, args), AVSESSION_SUCCESS);
713 SLOGE("SetSessionEventTest001 End");
714 }
715
716 /**
717 * @tc.name: SetSessionEventTest002
718 * @tc.desc: Set session event - large number of calls
719 * @tc.type: FUNC
720 * @tc.require: I6C6IN
721 */
722 HWTEST_F(AvsessionTest, SetSessionEventTest002, TestSize.Level2)
723 {
724 SLOGE("SetSessionEventTest002 Begin");
725 std::string event = "eventName";
726 OHOS::AAFwk::WantParams args;
727
728 // Test the interface through 500 calls
729 for (int i = 0; i < 500; i++) {
730 EXPECT_EQ(avsession_->SetSessionEvent(event, args), AVSESSION_SUCCESS);
731 }
732 SLOGE("SetSessionEventTest002 End");
733 }
734
735 /**
736 * @tc.name: GetAVPlaybackState001
737 * @tc.desc: Return the result of get av playback state
738 * @tc.type: FUNC
739 * @tc.require: AR000H31JF
740 */
741 HWTEST_F(AvsessionTest, GetAVPlaybackState001, TestSize.Level1)
742 {
743 SLOGE("GetAVPlaybackState001 Begin");
744 AVMetaData metaData;
745 metaData.Reset();
746 metaData.SetAssetId("playback");
747 metaData.SetDuration(2000000);
748 EXPECT_EQ(avsession_->SetAVMetaData(metaData), AVSESSION_SUCCESS);
749 g_playbackState.SetState(1);
750 g_playbackState.SetSpeed(1);
751 g_playbackState.SetPosition({80000, 0});
752 g_playbackState.SetBufferedTime(87000);
753 g_playbackState.SetLoopMode(1);
754 g_playbackState.SetFavorite(true);
755 EXPECT_EQ(avsession_->SetAVPlaybackState(g_playbackState), AVSESSION_SUCCESS);
756 AVPlaybackState state;
757 EXPECT_EQ(avsession_->GetAVPlaybackState(state), AVSESSION_SUCCESS);
758 EXPECT_EQ(state.GetState(), g_playbackState.GetState());
759 EXPECT_EQ(state.GetSpeed(), g_playbackState.GetSpeed());
760 EXPECT_EQ(state.GetPosition().elapsedTime_, g_playbackState.GetPosition().elapsedTime_);
761 EXPECT_EQ(state.GetBufferedTime(), g_playbackState.GetBufferedTime());
762 EXPECT_EQ(state.GetLoopMode(), g_playbackState.GetLoopMode());
763 EXPECT_EQ(state.GetFavorite(), g_playbackState.GetFavorite());
764 SLOGE("GetAVPlaybackState001 End");
765 }
766
767 /**
768 * @tc.name: SetLaunchAbility001
769 * @tc.desc: Return the result of set av launch ability
770 * @tc.type: FUNC
771 * @tc.require: AR000H31JF
772 */
773 HWTEST_F(AvsessionTest, SetLaunchAbility001, TestSize.Level1)
774 {
775 SLOGE("SetLaunchAbility001 Begin");
776 OHOS::AbilityRuntime::WantAgent::WantAgent ability;
777 EXPECT_EQ(avsession_->SetLaunchAbility(ability), AVSESSION_SUCCESS);
778 SLOGE("SetLaunchAbility001 End");
779 }
780
781 /**
782 * @tc.name: GetController001
783 * @tc.desc: Return shared_ptr of controller
784 * @tc.type: FUNC
785 * @tc.require: AR000H31JF
786 */
787 HWTEST_F(AvsessionTest, GetController001, TestSize.Level1)
788 {
789 SLOGE("GetController001 Begin");
790 auto controller = avsession_->GetController();
791 EXPECT_NE(controller, nullptr);
792 SLOGE("GetController001 End");
793 }
794
795 /**
796 * @tc.name: GetController002
797 * @tc.desc: Return shared_ptr of controller
798 * @tc.type: FUNC
799 * @tc.require: AR000H31JF
800 */
801 HWTEST_F(AvsessionTest, GetController002, TestSize.Level1)
802 {
803 SLOGE("GetController002 Begin");
804 auto controller = avsession_->GetController();
805 auto controller1 = avsession_->GetController();
806 EXPECT_NE(controller, nullptr);
807 EXPECT_NE(controller1, nullptr);
808 EXPECT_EQ(controller->Destroy(), AVSESSION_SUCCESS);
809 EXPECT_EQ(controller1->Destroy(), ERR_CONTROLLER_NOT_EXIST);
810 SLOGE("GetController002 End");
811 }
812
813 /**
814 * @tc.name: SetAVQueueItems
815 * @tc.desc: Set queue items of current application
816 * @tc.type: FUNC
817 * @tc.require: I6RJST
818 */
819 HWTEST_F(AvsessionTest, SetAVQueueItems, TestSize.Level1)
820 {
821 SLOGE("SetAVQueueItems Begin");
822 std::vector<AVQueueItem> items;
823 AVQueueItem queueItem;
824 queueItem.SetItemId(1);
825 AVMediaDescription description;
826 description.SetMediaId("id");
827 queueItem.SetDescription(std::make_shared<AVMediaDescription>(description));
828 items.push_back(queueItem);
829 EXPECT_EQ(avsession_->SetAVQueueItems(items), AVSESSION_SUCCESS);
830 SLOGE("SetAVQueueItems End");
831 }
832
833 /**
834 * @tc.name: SetAVQueueTitle
835 * @tc.desc: Set queue title of current application
836 * @tc.type: FUNC
837 * @tc.require: I6RJST
838 */
839 HWTEST_F(AvsessionTest, SetAVQueueTitle, TestSize.Level1)
840 {
841 SLOGE("SetAVQueueTitle Begin");
842 std::string title = "AVQueueTitle";
843 EXPECT_EQ(avsession_->SetAVQueueTitle(title), AVSESSION_SUCCESS);
844 SLOGE("SetAVQueueTitle End");
845 }
846
847 /**
848 * @tc.name: SetExtrasTest001
849 * @tc.desc: Set custom media packets
850 * @tc.type: FUNC
851 * @tc.require: I6TD43
852 */
853 HWTEST_F(AvsessionTest, SetExtrasTest001, TestSize.Level1)
854 {
855 SLOGI("SetExtrasTest001 Begin");
856 std::shared_ptr<OHOS::AAFwk::WantParams> wantParamsIn = nullptr;
857 wantParamsIn = std::make_shared<OHOS::AAFwk::WantParams>();
858 std::string keyStr = "1234567";
859 bool valueBool = true;
860 wantParamsIn->SetParam(keyStr, OHOS::AAFwk::Boolean::Box(valueBool));
861
862 EXPECT_EQ(avsession_->SetExtras(*wantParamsIn), AVSESSION_SUCCESS);
863 SLOGI("SetExtrasTest001 End");
864 }
865
866 /**
867 * @tc.name: SetExtrasTest002
868 * @tc.desc: Set custom media packets - large number of calls
869 * @tc.type: FUNC
870 * @tc.require: I6TD43
871 */
872 HWTEST_F(AvsessionTest, SetExtrasTest002, TestSize.Level2)
873 {
874 SLOGI("SetExtrasTest002 Begin");
875 std::shared_ptr<OHOS::AAFwk::WantParams> wantParamsIn = nullptr;
876 wantParamsIn = std::make_shared<OHOS::AAFwk::WantParams>();
877 std::string keyStr = "1234567";
878 bool valueBool = true;
879 wantParamsIn->SetParam(keyStr, OHOS::AAFwk::Boolean::Box(valueBool));
880
881 // Test the interface through 500 calls
882 for (int i = 0; i < 500; i++) {
883 EXPECT_EQ(avsession_->SetExtras(*wantParamsIn), AVSESSION_SUCCESS);
884 }
885 SLOGI("SetExtrasTest002 End");
886 }
887
888 /**
889 * @tc.name: RegisterCallback001
890 * @tc.desc: register avsession callback
891 * @tc.type: FUNC
892 * @tc.require: AR000H31JG
893 */
894 HWTEST_F(AvsessionTest, RegisterCallback001, TestSize.Level1)
895 {
896 SLOGE("RegisterCallback001 Begin");
897 std::shared_ptr<AVSessionCallback> callback = std::make_shared<AVSessionCallbackImpl>();
898 EXPECT_EQ(avsession_->RegisterCallback(callback), AVSESSION_SUCCESS);
899 SLOGE("RegisterCallback001 End");
900 }
901
902 /**
903 * @tc.name: RegisterCallback002
904 * @tc.desc: register avsession callback
905 * @tc.type: FUNC
906 * @tc.require: AR000H31JG
907 */
908 HWTEST_F(AvsessionTest, RegisterCallback002, TestSize.Level1)
909 {
910 SLOGE("RegisterCallback002 Begin");
911 std::shared_ptr<AVSessionCallback> callback = nullptr;
912 EXPECT_NE(avsession_->RegisterCallback(callback), AVSESSION_SUCCESS);
913 SLOGE("RegisterCallback002 End");
914 }
915
916 /**
917 * @tc.name: RegisterCallback003
918 * @tc.desc: register avsession callback
919 * @tc.type: FUNC
920 * @tc.require: AR000H31JG
921 */
922 HWTEST_F(AvsessionTest, RegisterCallback003, TestSize.Level1)
923 {
924 SLOGE("RegisterCallback003 Begin");
925 std::shared_ptr<AVSessionCallback> callback = std::make_shared<AVSessionCallbackImpl>();
926 EXPECT_EQ(avsession_->RegisterCallback(callback), AVSESSION_SUCCESS);
927 for (int32_t cmd = AVControlCommand::SESSION_CMD_PLAY; cmd < AVControlCommand::SESSION_CMD_MAX; cmd++) {
928 if (cmd == AVControlCommand::SESSION_CMD_MEDIA_KEY_SUPPORT) {
929 continue;
930 }
931 AVControlCommand controlCommand;
932 EXPECT_EQ(avsession_->AddSupportCommand(cmd), AVSESSION_SUCCESS);
933 EXPECT_EQ(controlCommand.SetCommand(cmd), AVSESSION_SUCCESS);
934 switch (cmd) {
935 case AVControlCommand::SESSION_CMD_SEEK : controlCommand.SetSeekTime(100000);
936 break;
937 case AVControlCommand::SESSION_CMD_SET_SPEED : controlCommand.SetSpeed(1.5);
938 break;
939 case AVControlCommand::SESSION_CMD_SET_LOOP_MODE : controlCommand.SetLoopMode(2);
940 break;
941 case AVControlCommand::SESSION_CMD_SET_TARGET_LOOP_MODE : controlCommand.SetTargetLoopMode(2);
942 break;
943 case AVControlCommand::SESSION_CMD_TOGGLE_FAVORITE : controlCommand.SetAssetId("callback");
944 break;
945 case AVControlCommand::SESSION_CMD_FAST_FORWARD : controlCommand.SetForwardTime(10);
946 break;
947 case AVControlCommand::SESSION_CMD_REWIND : controlCommand.SetRewindTime(10);
948 break;
949 case AVControlCommand::SESSION_CMD_PLAY_FROM_ASSETID: controlCommand.SetPlayFromAssetId(0);
950 break;
951 case AVControlCommand::SESSION_CMD_PLAY_WITH_ASSETID: controlCommand.SetPlayWithAssetId("0");
952 break;
953 default:
954 break;
955 }
956 bool isActive = false;
957 controller_->IsSessionActive(isActive);
958 if (!isActive) {
959 avsession_->Activate();
960 }
961 EXPECT_EQ(controller_->SendControlCommand(controlCommand), AVSESSION_SUCCESS);
962 sleep(1);
963 EXPECT_EQ(g_onCall, AVSESSION_SUCCESS);
964 g_onCall = false;
965 }
966 SLOGE("RegisterCallback003 End");
967 }
968
969 /**
970 * @tc.name: RegisterCallback004
971 * @tc.desc: register avsession callback
972 * @tc.type: FUNC
973 * @tc.require: AR000H31JG
974 */
975 HWTEST_F(AvsessionTest, RegisterCallback004, TestSize.Level1)
976 {
977 SLOGE("RegisterCallback004 Begin");
978 std::shared_ptr<AVSessionCallback> callback001 = std::make_shared<AVSessionCallbackImpl>();
979 EXPECT_NE(callback001, nullptr);
980 EXPECT_EQ(avsession_->RegisterCallback(callback001), AVSESSION_SUCCESS);
981 EXPECT_EQ(avsession_->RegisterCallback(callback001), AVSESSION_SUCCESS);
982 std::shared_ptr<AVSessionCallback> callback002 = std::make_shared<AVSessionCallbackImpl>();
983 EXPECT_NE(callback002, nullptr);
984 EXPECT_EQ(avsession_->RegisterCallback(callback002), AVSESSION_SUCCESS);
985 SLOGE("RegisterCallback004 End");
986 }
987
988 /**
989 * @tc.name: Active001
990 * @tc.desc: Return the active result
991 * @tc.type: FUNC
992 * @tc.require: AR000H31JF
993 */
994 HWTEST_F(AvsessionTest, Activate001, TestSize.Level1)
995 {
996 SLOGE("Activate001 Begin");
997 bool isActive = false;
998 EXPECT_EQ(avsession_->Activate(), AVSESSION_SUCCESS);
999 isActive = avsession_->IsActive();
1000 EXPECT_EQ(isActive, true);
1001 SLOGE("Activate001 End");
1002 }
1003
1004 /**
1005 * @tc.name: Disactive001
1006 * @tc.desc: Return is Session Actived
1007 * @tc.type: FUNC
1008 * @tc.require: AR000H31JF
1009 */
1010 HWTEST_F(AvsessionTest, Deactivate001, TestSize.Level1)
1011 {
1012 SLOGE("Deactivate001 Begin");
1013 bool isActive = true;
1014 EXPECT_EQ(avsession_->Deactivate(), AVSESSION_SUCCESS);
1015 isActive = avsession_->IsActive();
1016 EXPECT_EQ(isActive, false);
1017 SLOGE("Deactivate001 End");
1018 }
1019
1020 /**
1021 * @tc.name: AddSupportCommand001
1022 * @tc.desc: add supported commands
1023 * @tc.type: FUNC
1024 * @tc.require: AR000H31JF
1025 */
1026 HWTEST_F(AvsessionTest, AddSupportCommand001, TestSize.Level1)
1027 {
1028 SLOGE("AddSupportCommand001 Begin");
1029 EXPECT_EQ(avsession_->AddSupportCommand(AVControlCommand::SESSION_CMD_PLAY), AVSESSION_SUCCESS);
1030 EXPECT_EQ(avsession_->AddSupportCommand(AVControlCommand::SESSION_CMD_PAUSE), AVSESSION_SUCCESS);
1031 SLOGE("AddSupportCommand001 End");
1032 }
1033
1034 /**
1035 * @tc.name: AddSupportCommand002
1036 * @tc.desc: add supported commands
1037 * @tc.type: FUNC
1038 * @tc.require: AR000H31JF
1039 */
1040 HWTEST_F(AvsessionTest, AddSupportCommand002, TestSize.Level1)
1041 {
1042 SLOGE("AddSupportCommand002 Begin");
1043 EXPECT_EQ(avsession_->AddSupportCommand(AVControlCommand::SESSION_CMD_INVALID), AVSESSION_ERROR);
1044 EXPECT_EQ(avsession_->AddSupportCommand(AVControlCommand::SESSION_CMD_MAX), AVSESSION_ERROR);
1045 SLOGE("AddSupportCommand002 End");
1046 }
1047
1048 /**
1049 * @tc.name: AddSupportCommand003
1050 * @tc.desc: add supported commands
1051 * @tc.type: FUNC
1052 * @tc.require: AR000H31JF
1053 */
1054 HWTEST_F(AvsessionTest, AddSupportCommand003, TestSize.Level1)
1055 {
1056 SLOGE("AddSupportCommand003 Begin");
1057 for (int32_t cmd = AVControlCommand::SESSION_CMD_PLAY; cmd < AVControlCommand::SESSION_CMD_MAX; cmd++) {
1058 EXPECT_EQ(avsession_->AddSupportCommand(cmd), AVSESSION_SUCCESS);
1059 }
1060 std::vector<int32_t> cmds;
1061 EXPECT_EQ(controller_->GetValidCommands(cmds), AVSESSION_SUCCESS);
1062 EXPECT_EQ(cmds.size(), (AVControlCommand::SESSION_CMD_MAX - 1));
1063 for (int32_t index = 0; index < cmds.size(); index++) {
1064 EXPECT_EQ(cmds[index] > AVControlCommand::SESSION_CMD_INVALID, true);
1065 EXPECT_EQ(cmds[index] < AVControlCommand::SESSION_CMD_MAX, true);
1066 if (index >= AVControlCommand::SESSION_CMD_MEDIA_KEY_SUPPORT) {
1067 EXPECT_EQ(cmds[index], index + 1);
1068 } else {
1069 EXPECT_EQ(cmds[index], index);
1070 }
1071 }
1072 SLOGE("AddSupportCommand003 End");
1073 }
1074
1075 /**
1076 * @tc.name: deleteSupportCommand001
1077 * @tc.desc: delete supported commands
1078 * @tc.type: FUNC
1079 * @tc.require: AR000H31JF
1080 */
1081 HWTEST_F(AvsessionTest, deleteSupportCommand001, TestSize.Level1)
1082 {
1083 SLOGE("deleteSupportCommand001 Begin");
1084 for (int32_t cmd = AVControlCommand::SESSION_CMD_PLAY; cmd < AVControlCommand::SESSION_CMD_MAX; cmd++) {
1085 EXPECT_EQ(avsession_->AddSupportCommand(cmd), AVSESSION_SUCCESS);
1086 }
1087 std::vector<int32_t> cmds;
1088 EXPECT_EQ(controller_->GetValidCommands(cmds), AVSESSION_SUCCESS);
1089 EXPECT_EQ(cmds.size(), (AVControlCommand::SESSION_CMD_MAX - 1));
1090 for (int32_t cmd = AVControlCommand::SESSION_CMD_PLAY; cmd < AVControlCommand::SESSION_CMD_MAX; cmd++) {
1091 EXPECT_EQ(avsession_->DeleteSupportCommand(cmd), AVSESSION_SUCCESS);
1092 }
1093 cmds.clear();
1094 EXPECT_EQ(controller_->GetValidCommands(cmds), AVSESSION_SUCCESS);
1095 EXPECT_EQ(cmds.size(), 0);
1096 SLOGE("deleteSupportCommand001 End");
1097 }
1098
1099 /**
1100 * @tc.name: deleteSupportCommand002
1101 * @tc.desc: delete supported commands
1102 * @tc.type: FUNC
1103 * @tc.require: AR000H31JF
1104 */
1105 HWTEST_F(AvsessionTest, deleteSupportCommand002, TestSize.Level1)
1106 {
1107 SLOGE("deleteSupportCommand002 Begin");
1108 for (int32_t cmd = AVControlCommand::SESSION_CMD_PLAY; cmd < AVControlCommand::SESSION_CMD_MAX; cmd++) {
1109 EXPECT_EQ(avsession_->DeleteSupportCommand(cmd), AVSESSION_SUCCESS);
1110 }
1111 SLOGE("deleteSupportCommand002 End");
1112 }
1113
1114 /**
1115 * @tc.name: deleteSupportCommand003
1116 * @tc.desc: delete supported commands
1117 * @tc.type: FUNC
1118 * @tc.require: AR000H31JF
1119 */
1120 HWTEST_F(AvsessionTest, deleteSupportCommand003, TestSize.Level1)
1121 {
1122 SLOGE("deleteSupportCommand003 Begin");
1123 for (int32_t cmd = AVControlCommand::SESSION_CMD_PLAY; cmd < AVControlCommand::SESSION_CMD_MAX; cmd++) {
1124 EXPECT_EQ(avsession_->AddSupportCommand(cmd), AVSESSION_SUCCESS);
1125 }
1126 std::vector<int32_t> cmds;
1127 EXPECT_EQ(controller_->GetValidCommands(cmds), AVSESSION_SUCCESS);
1128 EXPECT_EQ(cmds.size(), (AVControlCommand::SESSION_CMD_MAX - 1));
1129 EXPECT_EQ(avsession_->DeleteSupportCommand(AVControlCommand::SESSION_CMD_INVALID), AVSESSION_ERROR);
1130 EXPECT_EQ(avsession_->DeleteSupportCommand(AVControlCommand::SESSION_CMD_MAX), AVSESSION_ERROR);
1131 SLOGE("deleteSupportCommand003 End");
1132 }
1133
1134 /**
1135 * @tc.name: Destroy001
1136 * @tc.desc: Return is Session destroyed result
1137 * @tc.type: FUNC
1138 * @tc.require: AR000H31JF
1139 */
1140 HWTEST_F(AvsessionTest, Destroy001, TestSize.Level1)
1141 {
1142 SLOGE("Destroy001 Begin");
1143 EXPECT_EQ(avsession_->Destroy(), AVSESSION_SUCCESS);
1144 avsession_ = nullptr;
1145 SLOGE("Destroy001 End");
1146 }
1147
1148 /**
1149 * @tc.name: Destroy002
1150 * @tc.desc: Return is Session destroyed result
1151 * @tc.type: FUNC
1152 * @tc.require: AR000H31JF
1153 */
1154 HWTEST_F(AvsessionTest, Destroy002, TestSize.Level1)
1155 {
1156 SLOGE("Destroy002 Begin");
1157 EXPECT_EQ(avsession_->Destroy(), AVSESSION_SUCCESS);
1158 EXPECT_EQ(avsession_->Destroy(), ERR_SESSION_NOT_EXIST);
1159 avsession_ = nullptr;
1160 SLOGE("Destroy002 End");
1161 }
1162
1163 /**
1164 * @tc.name: GetSessionType001
1165 * @tc.desc: GetSessionType
1166 * @tc.type: FUNC
1167 * @tc.require:
1168 */
1169 HWTEST_F(AvsessionTest, GetSessionType001, TestSize.Level1)
1170 {
1171 SLOGD("GetSessionType001 Begin");
1172 EXPECT_EQ(avsession_->GetSessionType(), "audio");
1173 SLOGD("GetSessionType001 End");
1174 }
1175
1176 /**
1177 * @tc.name: GetAVQueueItems001
1178 * @tc.desc: get que items
1179 * @tc.type: FUNC
1180 * @tc.require:
1181 */
1182 HWTEST_F(AvsessionTest, GetAVQueueItems001, TestSize.Level1)
1183 {
1184 SLOGD("GetAVQueueItems001 Begin");
1185 std::vector<AVQueueItem> items;
1186 EXPECT_EQ(avsession_->GetAVQueueItems(items), AVSESSION_SUCCESS);
1187 SLOGD("GetAVQueueItems001 End");
1188 }
1189
1190 /**
1191 * @tc.name: GetAVQueueTitle001
1192 * @tc.desc: get av que title
1193 * @tc.type: FUNC
1194 * @tc.require:
1195 */
1196 HWTEST_F(AvsessionTest, GetAVQueueTitle001, TestSize.Level1)
1197 {
1198 SLOGD("GetAVQueueTitle001 Begin");
1199 std::string title1 = "AVQueueTitle";
1200 std::string title2;
1201 EXPECT_EQ(avsession_->SetAVQueueTitle(title1), AVSESSION_SUCCESS);
1202 EXPECT_EQ(avsession_->GetAVQueueTitle(title2), AVSESSION_SUCCESS);
1203 SLOGD("GetAVQueueTitle001 End");
1204 }
1205
1206 /**
1207 * @tc.name: GetExtras001
1208 * @tc.desc: get extras
1209 * @tc.type: FUNC
1210 * @tc.require:
1211 */
1212 HWTEST_F(AvsessionTest, GetExtras001, TestSize.Level1)
1213 {
1214 SLOGD("GetExtras001 Begin");
1215 std::shared_ptr<OHOS::AAFwk::WantParams> wantParamsIn = nullptr;
1216 wantParamsIn = std::make_shared<OHOS::AAFwk::WantParams>();
1217 std::string keyStr = "1234567";
1218 bool valueBool = true;
1219 wantParamsIn->SetParam(keyStr, OHOS::AAFwk::Boolean::Box(valueBool));
1220 OHOS::AAFwk::WantParams wantParamsOut;
1221 EXPECT_EQ(avsession_->SetExtras(*wantParamsIn), AVSESSION_SUCCESS);
1222 EXPECT_EQ(avsession_->GetExtras(wantParamsOut), AVSESSION_SUCCESS);
1223 SLOGD("GetExtras001 End");
1224 }
1225
1226 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
1227 /**
1228 * @tc.name: GetAllCastDisplays001
1229 * @tc.desc: get all cast displays
1230 * @tc.type: FUNC
1231 * @tc.require:
1232 */
1233 HWTEST_F(AvsessionTest, GetAllCastDisplays001, TestSize.Level1)
1234 {
1235 SLOGD("GetAllCastDisplays001 Begin");
1236 std::vector<CastDisplayInfo> castDisplays;
1237 EXPECT_EQ(avsession_->GetAllCastDisplays(castDisplays), AVSESSION_SUCCESS);
1238 SLOGD("GetAllCastDisplays001 End");
1239 }
1240 #endif
1241
1242 /**
1243 * @tc.name: UpdateAVQueueInfo001
1244 * @tc.desc: update avqueue info
1245 * @tc.type: FUNC
1246 * @tc.require:
1247 */
1248 HWTEST_F(AvsessionTest, UpdateAVQueueInfo001, TestSize.Level1)
1249 {
1250 SLOGD("UpdateAVQueueInfo001 Begin");
1251 AVQueueInfo info = AVQueueInfo();
1252 EXPECT_EQ(avsession_->UpdateAVQueueInfo(info), AVSESSION_SUCCESS);
1253 SLOGD("UpdateAVQueueInfo001 End");
1254 }
1255
1256 /**
1257 * @tc.name: AVSessionDemoUpdateAVQueueInfo001
1258 * @tc.desc: create AVSessionDemo and UpdateAVQueueInfo
1259 * @tc.type: FUNC
1260 * @tc.require:
1261 */
1262 HWTEST_F(AvsessionTest, AVSessionDemoUpdateAVQueueInfo001, TestSize.Level1)
1263 {
1264 SLOGE("AVSessionDemoUpdateAVQueueInfo001 Begin");
1265 AVSessionDemo avsessionDemo = AVSessionDemo();
1266 AVQueueInfo info = AVQueueInfo();
1267 EXPECT_EQ(avsessionDemo.UpdateAVQueueInfo(info), AVSESSION_SUCCESS);
1268 SLOGE("AVSessionDemoUpdateAVQueueInfo001 End");
1269 }
1270 } // namespace AVSession
1271 } // namespace OHOS
1272