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 #include <memory>
18 #include <fstream>
19 #include <cstdio>
20
21 #include "avsession_log.h"
22 #include "input_manager.h"
23 #include "key_event.h"
24 #include "avsession_manager.h"
25 #include "avsession_errors.h"
26 #include "avmeta_data.h"
27 #include "avplayback_state.h"
28 #include "avmedia_description.h"
29 #include "avqueue_item.h"
30 #include "avsession_log.h"
31 #include "nativetoken_kit.h"
32 #include "token_setproc.h"
33 #include "accesstoken_kit.h"
34 #include "system_ability_definition.h"
35 #include "system_ability_ondemand_reason.h"
36 #include "audio_info.h"
37 #include "avsession_callback_client.h"
38 #include "avsession_pixel_map.h"
39 #include "avsession_pixel_map_adapter.h"
40 #include "avsession_info.h"
41
42 #define private public
43 #define protected public
44 #include "avsession_service.h"
45 #undef protected
46 #undef private
47
48 using namespace testing::ext;
49 using namespace OHOS::AVSession;
50 using namespace OHOS::Security::AccessToken;
51 using namespace OHOS::AudioStandard;
52 static AVMetaData g_metaData;
53 static AVPlaybackState g_playbackState;
54 static char g_testSessionTag[] = "test";
55 static char g_testAnotherBundleName[] = "testAnother.ohos.avsession";
56 static char g_testAnotherAbilityName[] = "testAnother.ability";
57 static int32_t g_playOnCall = AVSESSION_ERROR;
58 static int32_t g_pauseOnCall = AVSESSION_ERROR;
59 static int32_t g_nextOnCall = AVSESSION_ERROR;
60 static int32_t g_previousOnCall = AVSESSION_ERROR;
61 static AVSessionService *avservice_;
62
63 class AVSessionServiceTest : public testing::Test {
64 public:
65 static void SetUpTestCase();
66 static void TearDownTestCase();
67 void SetUp() override;
68 void TearDown() override;
69
70 std::shared_ptr<AVSession> avsession_ = nullptr;
71 };
72
SetUpTestCase()73 void AVSessionServiceTest::SetUpTestCase()
74 {
75 SLOGI("set up AVSessionServiceTest");
76 system("killall -9 com.example.hiMusicDemo");
77 sleep(1);
78 avservice_ = new AVSessionService(OHOS::AVSESSION_SERVICE_ID);
79 avservice_->InitKeyEvent();
80 }
81
TearDownTestCase()82 void AVSessionServiceTest::TearDownTestCase()
83 {
84 }
85
SetUp()86 void AVSessionServiceTest::SetUp()
87 {
88 SLOGI("set up test function in AVSessionServiceTest");
89 }
90
TearDown()91 void AVSessionServiceTest::TearDown()
92 {
93 SLOGI("tear down test function in AVSessionServiceTest");
94 [[maybe_unused]] int32_t ret = AVSESSION_ERROR;
95 if (avsession_ != nullptr) {
96 ret = avsession_->Destroy();
97 avsession_ = nullptr;
98 }
99 }
100
101 class AVSessionCallbackImpl : public AVSessionCallback {
102 public:
103 void OnPlay() override;
104 void OnPause() override;
OnStop()105 void OnStop() override {};
106 void OnPlayNext() override;
107 void OnPlayPrevious() override;
OnFastForward(int64_t time)108 void OnFastForward(int64_t time) override {};
OnRewind(int64_t time)109 void OnRewind(int64_t time) override {};
OnSeek(int64_t time)110 void OnSeek(int64_t time) override {};
OnSetSpeed(double speed)111 void OnSetSpeed(double speed) override {};
OnSetLoopMode(int32_t loopMode)112 void OnSetLoopMode(int32_t loopMode) override {};
OnSetTargetLoopMode(int32_t targetLoopMode)113 void OnSetTargetLoopMode(int32_t targetLoopMode) override {};
OnToggleFavorite(const std::string & mediaId)114 void OnToggleFavorite(const std::string& mediaId) override {};
OnMediaKeyEvent(const OHOS::MMI::KeyEvent & keyEvent)115 void OnMediaKeyEvent(const OHOS::MMI::KeyEvent& keyEvent) override {};
OnOutputDeviceChange(const int32_t connectionState,const OHOS::AVSession::OutputDeviceInfo & outputDeviceInfo)116 void OnOutputDeviceChange(const int32_t connectionState,
117 const OHOS::AVSession::OutputDeviceInfo& outputDeviceInfo) override {};
OnCommonCommand(const std::string & commonCommand,const OHOS::AAFwk::WantParams & commandArgs)118 void OnCommonCommand(const std::string& commonCommand, const OHOS::AAFwk::WantParams& commandArgs) override {};
OnSkipToQueueItem(int32_t itemId)119 void OnSkipToQueueItem(int32_t itemId) override {};
OnAVCallAnswer()120 void OnAVCallAnswer() override {};
OnAVCallHangUp()121 void OnAVCallHangUp() override {};
OnAVCallToggleCallMute()122 void OnAVCallToggleCallMute() override {};
OnPlayFromAssetId(int64_t assetId)123 void OnPlayFromAssetId(int64_t assetId) override {};
OnCastDisplayChange(const CastDisplayInfo & castDisplayInfo)124 void OnCastDisplayChange(const CastDisplayInfo& castDisplayInfo) override {};
125
126 ~AVSessionCallbackImpl() override;
127 };
128
OnPlay()129 void AVSessionCallbackImpl::OnPlay()
130 {
131 g_playOnCall = AVSESSION_SUCCESS;
132 SLOGI("OnPlay %{public}d", g_playOnCall);
133 }
134
OnPause()135 void AVSessionCallbackImpl::OnPause()
136 {
137 g_pauseOnCall = AVSESSION_SUCCESS;
138 SLOGI("OnPause %{public}d", g_pauseOnCall);
139 }
140
OnPlayNext()141 void AVSessionCallbackImpl::OnPlayNext()
142 {
143 g_nextOnCall = AVSESSION_SUCCESS;
144 SLOGI("OnPlayNext %{public}d", g_nextOnCall);
145 }
146
OnPlayPrevious()147 void AVSessionCallbackImpl::OnPlayPrevious()
148 {
149 g_previousOnCall = AVSESSION_SUCCESS;
150 SLOGI("OnPlayPrevious %{public}d", g_previousOnCall);
151 }
152
~AVSessionCallbackImpl()153 AVSessionCallbackImpl::~AVSessionCallbackImpl()
154 {
155 }
156
157 /**
158 * @tc.name: SendSystemAVKeyEvent001
159 * @tc.desc: verifying send system keyEvent
160 * @tc.type: FUNC
161 * @tc.require: #I5Y4MZ
162 */
163 static HWTEST_F(AVSessionServiceTest, SendSystemAVKeyEvent001, TestSize.Level1)
164 {
165 SLOGI("SendSystemAVKeyEvent001 begin!");
166 OHOS::AppExecFwk::ElementName elementName;
167 elementName.SetBundleName(g_testAnotherBundleName);
168 elementName.SetAbilityName(g_testAnotherAbilityName);
169 OHOS::sptr<AVSessionItem> avsessionHere_ =
170 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
171 avsessionHere_->Activate();
172 avservice_->UpdateTopSession(avsessionHere_);
173
174 g_metaData.Reset();
175 g_metaData.SetAssetId("123");
176 g_metaData.SetTitle("Black Humor");
177 g_metaData.SetArtist("zhoujielun");
178 g_metaData.SetAuthor("zhoujielun");
179 g_metaData.SetAlbum("Jay");
180 g_metaData.SetWriter("zhoujielun");
181 g_metaData.SetComposer("zhoujielun");
182 g_metaData.SetDuration(40000);
183 g_metaData.SetMediaImageUri("xxxxx");
184 g_metaData.SetSubTitle("fac");
185 g_metaData.SetDescription("for friends");
186 g_metaData.SetLyric("xxxxx");
187 avsessionHere_->SetAVMetaData(g_metaData);
188
189 g_playbackState.SetState(AVPlaybackState::PLAYBACK_STATE_PLAY);
190 g_playbackState.SetSpeed(1.5);
191 g_playbackState.SetPosition({80000, 0});
192 g_playbackState.SetBufferedTime(60000);
193 g_playbackState.SetLoopMode(2);
194 g_playbackState.SetFavorite(true);
195 avsessionHere_->SetAVPlaybackState(g_playbackState);
196
197 std::shared_ptr<AVSessionCallback> callback = std::make_shared<AVSessionCallbackImpl>();
198 OHOS::sptr<IAVSessionCallback> callbackClient = new(std::nothrow) AVSessionCallbackClient(callback);
199 EXPECT_EQ(avsessionHere_->RegisterCallbackInner(callbackClient), AVSESSION_SUCCESS);
200
201 auto keyEvent = OHOS::MMI::KeyEvent::Create();
202 ASSERT_NE(keyEvent, nullptr);
203 keyEvent->SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HEADSETHOOK);
204 keyEvent->SetKeyAction(OHOS::MMI::KeyEvent::KEY_ACTION_DOWN);
205 OHOS::MMI::KeyEvent::KeyItem item;
206 item.SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HEADSETHOOK);
207 item.SetDownTime(0);
208 item.SetPressed(true);
209 keyEvent->AddPressedKeyItems(item);
210 OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
211 sleep(1);
212 EXPECT_EQ(g_pauseOnCall, AVSESSION_SUCCESS);
213 g_pauseOnCall = false;
214 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
215 SLOGI("SendSystemAVKeyEvent001 end!");
216 }
217
218 /**
219 * @tc.name: SendSystemAVKeyEvent002
220 * @tc.desc: verifying send system keyEvent
221 * @tc.type: FUNC
222 * @tc.require: #I5Y4MZ
223 */
224
225 static HWTEST_F(AVSessionServiceTest, SendSystemAVKeyEvent002, TestSize.Level1)
226 {
227 SLOGI("SendSystemAVKeyEvent002 begin!");
228 OHOS::AppExecFwk::ElementName elementName;
229 elementName.SetBundleName(g_testAnotherBundleName);
230 elementName.SetAbilityName(g_testAnotherAbilityName);
231 OHOS::sptr<AVSessionItem> avsessionHere_ =
232 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
233 avsessionHere_->Activate();
234 avservice_->UpdateTopSession(avsessionHere_);
235
236 g_metaData.Reset();
237 g_metaData.SetAssetId("123");
238 g_metaData.SetTitle("Black Humor");
239 g_metaData.SetArtist("zhoujielun");
240 g_metaData.SetAuthor("zhoujielun");
241 g_metaData.SetAlbum("Jay");
242 g_metaData.SetWriter("zhoujielun");
243 g_metaData.SetComposer("zhoujielun");
244 g_metaData.SetDuration(40000);
245 g_metaData.SetMediaImageUri("xxxxx");
246 g_metaData.SetSubTitle("fac");
247 g_metaData.SetDescription("for friends");
248 g_metaData.SetLyric("xxxxx");
249 avsessionHere_->SetAVMetaData(g_metaData);
250
251 g_playbackState.SetState(AVPlaybackState::PLAYBACK_STATE_PAUSE);
252 g_playbackState.SetSpeed(1.5);
253 g_playbackState.SetPosition({80000, 0});
254 g_playbackState.SetBufferedTime(60000);
255 g_playbackState.SetLoopMode(2);
256 g_playbackState.SetFavorite(true);
257 avsessionHere_->SetAVPlaybackState(g_playbackState);
258
259 std::shared_ptr<AVSessionCallback> callback = std::make_shared<AVSessionCallbackImpl>();
260 OHOS::sptr<IAVSessionCallback> callbackClient = new(std::nothrow) AVSessionCallbackClient(callback);
261 EXPECT_EQ(avsessionHere_->RegisterCallbackInner(callbackClient), AVSESSION_SUCCESS);
262
263 auto keyEvent = OHOS::MMI::KeyEvent::Create();
264 ASSERT_NE(keyEvent, nullptr);
265 keyEvent->SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HEADSETHOOK);
266 keyEvent->SetKeyAction(OHOS::MMI::KeyEvent::KEY_ACTION_DOWN);
267 OHOS::MMI::KeyEvent::KeyItem item;
268 item.SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HEADSETHOOK);
269 item.SetDownTime(0);
270 item.SetPressed(true);
271 keyEvent->AddPressedKeyItems(item);
272 OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
273 sleep(1);
274 EXPECT_EQ(g_playOnCall, AVSESSION_SUCCESS);
275 g_playOnCall = false;
276 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
277 SLOGI("SendSystemAVKeyEvent002 end!");
278 }
279
280 /**
281 * @tc.name: SendSystemAVKeyEvent003
282 * @tc.desc: verifying send system keyEvent
283 * @tc.type: FUNC
284 * @tc.require: #I5Y4MZ
285 */
286 static HWTEST_F(AVSessionServiceTest, SendSystemAVKeyEvent003, TestSize.Level1)
287 {
288 SLOGI("SendSystemAVKeyEvent003 begin!");
289 OHOS::AppExecFwk::ElementName elementName;
290 elementName.SetBundleName(g_testAnotherBundleName);
291 elementName.SetAbilityName(g_testAnotherAbilityName);
292 OHOS::sptr<AVSessionItem> avsessionHere_ =
293 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
294 avsessionHere_->Activate();
295 avservice_->UpdateTopSession(avsessionHere_);
296
297 g_metaData.Reset();
298 g_metaData.SetAssetId("123");
299 g_metaData.SetTitle("Black Humor");
300 g_metaData.SetArtist("zhoujielun");
301 g_metaData.SetAuthor("zhoujielun");
302 g_metaData.SetAlbum("Jay");
303 g_metaData.SetWriter("zhoujielun");
304 g_metaData.SetComposer("zhoujielun");
305 g_metaData.SetDuration(40000);
306 g_metaData.SetMediaImageUri("xxxxx");
307 g_metaData.SetSubTitle("fac");
308 g_metaData.SetDescription("for friends");
309 g_metaData.SetLyric("xxxxx");
310 avsessionHere_->SetAVMetaData(g_metaData);
311
312 g_playbackState.SetState(AVPlaybackState::PLAYBACK_STATE_PLAY);
313 g_playbackState.SetSpeed(1.5);
314 g_playbackState.SetPosition({80000, 0});
315 g_playbackState.SetBufferedTime(60000);
316 g_playbackState.SetLoopMode(2);
317 g_playbackState.SetFavorite(true);
318 avsessionHere_->SetAVPlaybackState(g_playbackState);
319
320 std::shared_ptr<AVSessionCallback> callback = std::make_shared<AVSessionCallbackImpl>();
321 OHOS::sptr<IAVSessionCallback> callbackClient = new(std::nothrow) AVSessionCallbackClient(callback);
322 EXPECT_EQ(avsessionHere_->RegisterCallbackInner(callbackClient), AVSESSION_SUCCESS);
323
324 auto keyEvent = OHOS::MMI::KeyEvent::Create();
325 ASSERT_NE(keyEvent, nullptr);
326 keyEvent->SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HEADSETHOOK);
327 keyEvent->SetKeyAction(OHOS::MMI::KeyEvent::KEY_ACTION_DOWN);
328 OHOS::MMI::KeyEvent::KeyItem item;
329 item.SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HEADSETHOOK);
330 item.SetDownTime(0);
331 item.SetPressed(true);
332 keyEvent->AddPressedKeyItems(item);
333 OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
334 OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
335 sleep(1);
336 EXPECT_EQ(g_nextOnCall, AVSESSION_SUCCESS);
337 g_nextOnCall = false;
338 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
339 SLOGI("SendSystemAVKeyEvent003 end!");
340 }
341
342 /**
343 * @tc.name: SendSystemAVKeyEvent004
344 * @tc.desc: verifying send system keyEvent
345 * @tc.type: FUNC
346 * @tc.require: #I5Y4MZ
347 */
348 static HWTEST_F(AVSessionServiceTest, SendSystemAVKeyEvent004, TestSize.Level1)
349 {
350 SLOGI("SendSystemAVKeyEvent004 begin!");
351 OHOS::AppExecFwk::ElementName elementName;
352 elementName.SetBundleName(g_testAnotherBundleName);
353 elementName.SetAbilityName(g_testAnotherAbilityName);
354 OHOS::sptr<AVSessionItem> avsessionHere_ =
355 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
356 avsessionHere_->Activate();
357 avservice_->UpdateTopSession(avsessionHere_);
358 g_metaData.SetAssetId("123");
359 g_metaData.SetTitle("Black Humor");
360 g_metaData.SetArtist("zhoujielun");
361 g_metaData.SetAuthor("zhoujielun");
362 g_metaData.SetAlbum("Jay");
363 g_metaData.SetWriter("zhoujielun");
364 g_metaData.SetComposer("zhoujielun");
365 g_metaData.SetDuration(40000);
366 g_metaData.SetSubTitle("fac");
367 g_metaData.SetDescription("for friends");
368 g_metaData.SetLyric("xxxxx");
369 avsessionHere_->SetAVMetaData(g_metaData);
370 g_playbackState.SetState(AVPlaybackState::PLAYBACK_STATE_PLAY);
371 g_playbackState.SetSpeed(1.5);
372 g_playbackState.SetPosition({80000, 0});
373 g_playbackState.SetBufferedTime(60000);
374 g_playbackState.SetLoopMode(2);
375 g_playbackState.SetFavorite(true);
376 avsessionHere_->SetAVPlaybackState(g_playbackState);
377 std::shared_ptr<AVSessionCallback> callback = std::make_shared<AVSessionCallbackImpl>();
378 OHOS::sptr<IAVSessionCallback> callbackClient = new(std::nothrow) AVSessionCallbackClient(callback);
379 EXPECT_EQ(avsessionHere_->RegisterCallbackInner(callbackClient), AVSESSION_SUCCESS);
380 auto keyEvent = OHOS::MMI::KeyEvent::Create();
381 ASSERT_NE(keyEvent, nullptr);
382 keyEvent->SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HEADSETHOOK);
383 keyEvent->SetKeyAction(OHOS::MMI::KeyEvent::KEY_ACTION_DOWN);
384 OHOS::MMI::KeyEvent::KeyItem item;
385 item.SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HEADSETHOOK);
386 item.SetDownTime(0);
387 item.SetPressed(true);
388 keyEvent->AddPressedKeyItems(item);
389 OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
390 OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
391 OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
392 sleep(1);
393 EXPECT_EQ(g_previousOnCall, AVSESSION_SUCCESS);
394 g_previousOnCall = false;
395 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
396 SLOGI("SendSystemAVKeyEvent004 end!");
397 }
398
399 /**
400 * @tc.name: SendSystemAVKeyEvent005
401 * @tc.desc: verifying send system keyEvent
402 * @tc.type: FUNC
403 * @tc.require: #I5Y4MZ
404 */
405 static HWTEST_F(AVSessionServiceTest, SendSystemAVKeyEvent005, TestSize.Level1)
406 {
407 SLOGI("SendSystemAVKeyEvent005 begin!");
408 OHOS::AppExecFwk::ElementName elementName;
409 elementName.SetBundleName(g_testAnotherBundleName);
410 elementName.SetAbilityName(g_testAnotherAbilityName);
411 OHOS::sptr<AVSessionItem> avsessionHere_ =
412 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
413 avsessionHere_->Activate();
414 avservice_->UpdateTopSession(avsessionHere_);
415 g_metaData.SetAssetId("123");
416 g_metaData.SetTitle("Black Humor");
417 g_metaData.SetArtist("zhoujielun");
418 g_metaData.SetAuthor("zhoujielun");
419 g_metaData.SetAlbum("Jay");
420 g_metaData.SetWriter("zhoujielun");
421 g_metaData.SetComposer("zhoujielun");
422 g_metaData.SetDuration(40000);
423 g_metaData.SetMediaImageUri("xxxxx");
424 g_metaData.SetDescription("for friends");
425 avsessionHere_->SetAVMetaData(g_metaData);
426 g_playbackState.SetState(AVPlaybackState::PLAYBACK_STATE_PLAY);
427 g_playbackState.SetSpeed(1.5);
428 g_playbackState.SetPosition({80000, 0});
429 g_playbackState.SetBufferedTime(60000);
430 g_playbackState.SetLoopMode(2);
431 g_playbackState.SetFavorite(true);
432 avsessionHere_->SetAVPlaybackState(g_playbackState);
433 std::shared_ptr<AVSessionCallback> callback = std::make_shared<AVSessionCallbackImpl>();
434 OHOS::sptr<IAVSessionCallback> callbackClient = new(std::nothrow) AVSessionCallbackClient(callback);
435 EXPECT_EQ(avsessionHere_->RegisterCallbackInner(callbackClient), AVSESSION_SUCCESS);
436 auto keyEvent = OHOS::MMI::KeyEvent::Create();
437 ASSERT_NE(keyEvent, nullptr);
438 keyEvent->SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HEADSETHOOK);
439 keyEvent->SetKeyAction(OHOS::MMI::KeyEvent::KEY_ACTION_DOWN);
440 OHOS::MMI::KeyEvent::KeyItem item;
441 item.SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HEADSETHOOK);
442 item.SetDownTime(0);
443 item.SetPressed(true);
444 keyEvent->AddPressedKeyItems(item);
445 OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
446 OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
447 OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
448 OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
449 sleep(1);
450 EXPECT_EQ(g_previousOnCall, AVSESSION_SUCCESS);
451 g_previousOnCall = false;
452 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
453 SLOGI("SendSystemAVKeyEvent005 end!");
454 }
455
456 /**
457 * @tc.name: SendSystemAVKeyEvent006
458 * @tc.desc: verifying send system keyEvent
459 * @tc.type: FUNC
460 * @tc.require: #I5Y4MZ
461 */
462 static HWTEST_F(AVSessionServiceTest, SendSystemAVKeyEvent006, TestSize.Level1)
463 {
464 SLOGI("SendSystemAVKeyEvent006 begin!");
465 OHOS::AppExecFwk::ElementName elementName;
466 elementName.SetBundleName(g_testAnotherBundleName);
467 elementName.SetAbilityName(g_testAnotherAbilityName);
468 OHOS::sptr<AVSessionItem> avsessionHere_ =
469 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
470 avsessionHere_->Activate();
471 avservice_->UpdateTopSession(avsessionHere_);
472 g_metaData.SetAssetId("123");
473 g_metaData.SetTitle("Black Humor");
474 g_metaData.SetArtist("zhoujielun");
475 g_metaData.SetAuthor("zhoujielun");
476 g_metaData.SetAlbum("Jay");
477 g_metaData.SetWriter("zhoujielun");
478 g_metaData.SetComposer("zhoujielun");
479 g_metaData.SetDuration(40000);
480 avsessionHere_->SetAVMetaData(g_metaData);
481 g_playbackState.SetState(AVPlaybackState::PLAYBACK_STATE_PLAY);
482 g_playbackState.SetSpeed(1.5);
483 g_playbackState.SetPosition({80000, 0});
484 g_playbackState.SetBufferedTime(60000);
485 g_playbackState.SetLoopMode(2);
486 g_playbackState.SetFavorite(true);
487 avsessionHere_->SetAVPlaybackState(g_playbackState);
488 std::shared_ptr<AVSessionCallback> callback = std::make_shared<AVSessionCallbackImpl>();
489 OHOS::sptr<IAVSessionCallback> callbackClient = new(std::nothrow) AVSessionCallbackClient(callback);
490 EXPECT_EQ(avsessionHere_->RegisterCallbackInner(callbackClient), AVSESSION_SUCCESS);
491 auto keyEvent = OHOS::MMI::KeyEvent::Create();
492 ASSERT_NE(keyEvent, nullptr);
493 keyEvent->SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HEADSETHOOK);
494 keyEvent->SetKeyAction(OHOS::MMI::KeyEvent::KEY_ACTION_DOWN);
495 OHOS::MMI::KeyEvent::KeyItem item;
496 item.SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HEADSETHOOK);
497 item.SetDownTime(0);
498 item.SetPressed(true);
499 keyEvent->AddPressedKeyItems(item);
500 OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
501 OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
502 sleep(1);
503 EXPECT_EQ(g_nextOnCall, AVSESSION_SUCCESS);
504 g_nextOnCall = false;
505 OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
506 sleep(1);
507 EXPECT_EQ(g_pauseOnCall, AVSESSION_SUCCESS);
508 g_pauseOnCall = false;
509 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
510 SLOGI("SendSystemAVKeyEvent006 end!");
511 }
512
513 static HWTEST_F(AVSessionServiceTest, NotifyDeviceAvailable001, TestSize.Level1)
514 {
515 SLOGI("NotifyDeviceAvailable001 begin!");
516 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
517 SLOGI("NotifyDeviceAvailable001 in!");
518 OutputDeviceInfo outputDeviceInfo;
519 OHOS::AVSession::DeviceInfo deviceInfo;
520 deviceInfo.castCategory_ = 1;
521 deviceInfo.deviceId_ = "deviceId";
522 outputDeviceInfo.deviceInfos_.push_back(deviceInfo);
523 avservice_->NotifyDeviceAvailable(outputDeviceInfo);
524 EXPECT_EQ(0, AVSESSION_SUCCESS);
525 #endif
526 EXPECT_EQ(0, AVSESSION_SUCCESS);
527 SLOGI("NotifyDeviceAvailable001 end!");
528 }
529
530 static HWTEST_F(AVSessionServiceTest, NotifyMirrorToStreamCast001, TestSize.Level1)
531 {
532 SLOGI("NotifyMirrorToStreamCast001 begin!");
533 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
534 SLOGI("NotifyMirrorToStreamCast001 in!");
535 avservice_->NotifyMirrorToStreamCast();
536 #endif
537 EXPECT_EQ(0, AVSESSION_SUCCESS);
538 SLOGI("NotifyMirrorToStreamCast001 end!");
539 }
540
541 static HWTEST_F(AVSessionServiceTest, NotifyMirrorToStreamCast002, TestSize.Level1)
542 {
543 SLOGI("NotifyMirrorToStreamCast002 begin!");
544 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
545 SLOGI("NotifyMirrorToStreamCast002 in!");
546 OHOS::AppExecFwk::ElementName elementName;
547 elementName.SetBundleName(g_testAnotherBundleName);
548 elementName.SetAbilityName(g_testAnotherAbilityName);
549 OHOS::sptr<AVSessionItem> avsessionHere_ =
550 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
551 EXPECT_EQ(avsessionHere_ != nullptr, true);
552 avservice_->UpdateTopSession(avsessionHere_);
553 avservice_->NotifyMirrorToStreamCast();
554 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
555 #endif
556 EXPECT_EQ(0, AVSESSION_SUCCESS);
557 SLOGI("NotifyMirrorToStreamCast002 end!");
558 }
559
560 static HWTEST_F(AVSessionServiceTest, NotifyMirrorToStreamCast003, TestSize.Level1)
561 {
562 SLOGI("NotifyMirrorToStreamCast003 begin!");
563 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
564 SLOGI("NotifyMirrorToStreamCast002 in!");
565 OHOS::AppExecFwk::ElementName elementName;
566 elementName.SetBundleName(g_testAnotherBundleName);
567 elementName.SetAbilityName(g_testAnotherAbilityName);
568 OHOS::sptr<AVSessionItem> avsessionHere_ =
569 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_VIDEO, false, elementName);
570 EXPECT_EQ(avsessionHere_ != nullptr, true);
571 avservice_->UpdateTopSession(avsessionHere_);
572 avservice_->NotifyMirrorToStreamCast();
573 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
574 #endif
575 EXPECT_EQ(0, AVSESSION_SUCCESS);
576 SLOGI("NotifyMirrorToStreamCast003 end!");
577 }
578
579 static HWTEST_F(AVSessionServiceTest, RefreshFocusSessionSort001, TestSize.Level1)
580 {
581 SLOGI("RefreshFocusSessionSort001 begin!");
582 OHOS::AppExecFwk::ElementName elementName;
583 elementName.SetBundleName(g_testAnotherBundleName);
584 elementName.SetAbilityName(g_testAnotherAbilityName);
585 OHOS::sptr<AVSessionItem> avsessionHere_ =
586 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
587 EXPECT_EQ(avsessionHere_ != nullptr, true);
588 avservice_->RefreshFocusSessionSort(avsessionHere_);
589 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
590 EXPECT_EQ(0, AVSESSION_SUCCESS);
591 SLOGI("RefreshFocusSessionSort001 end!");
592 }
593
594 static HWTEST_F(AVSessionServiceTest, SelectSessionByUid001, TestSize.Level1)
595 {
596 SLOGI("SelectSessionByUid001 begin!");
597 OHOS::AppExecFwk::ElementName elementName;
598 elementName.SetBundleName(g_testAnotherBundleName);
599 elementName.SetAbilityName(g_testAnotherAbilityName);
600 OHOS::sptr<AVSessionItem> avsessionHere_ =
601 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
602 EXPECT_EQ(avsessionHere_ != nullptr, true);
603 AudioRendererChangeInfo info = {};
604 info.clientUID = 0;
605 avservice_->SelectSessionByUid(info);
606 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
607 EXPECT_EQ(0, AVSESSION_SUCCESS);
608 SLOGI("SelectSessionByUid001 end!");
609 }
610
611 static HWTEST_F(AVSessionServiceTest, SelectSessionByUid002, TestSize.Level1)
612 {
613 SLOGI("SelectSessionByUid002 begin!");
614 OHOS::AppExecFwk::ElementName elementName;
615 elementName.SetBundleName(g_testAnotherBundleName);
616 elementName.SetAbilityName(g_testAnotherAbilityName);
617 OHOS::sptr<AVSessionItem> avsessionHere_ =
618 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
619 EXPECT_EQ(avsessionHere_ != nullptr, true);
620 AudioRendererChangeInfo info = {};
621 info.clientUID = avsessionHere_->GetUid();
622 avservice_->SelectSessionByUid(info);
623 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
624 EXPECT_EQ(0, AVSESSION_SUCCESS);
625 SLOGI("SelectSessionByUid002 end!");
626 }
627
628 static HWTEST_F(AVSessionServiceTest, InitBMS001, TestSize.Level1)
629 {
630 SLOGI("InitBMS001 stop to prevent crash in SubscribeBundleStatusEvent");
631 EXPECT_EQ(0, AVSESSION_SUCCESS);
632 SLOGI("InitBMS001 end!");
633 }
634
635 static HWTEST_F(AVSessionServiceTest, ReleaseCastSession001, TestSize.Level1)
636 {
637 SLOGI("ReleaseCastSession001 begin!");
638 OHOS::AppExecFwk::ElementName elementName;
639 elementName.SetBundleName(g_testAnotherBundleName);
640 elementName.SetAbilityName(g_testAnotherAbilityName);
641 OHOS::sptr<AVSessionItem> avsessionHere_ =
642 avservice_->CreateSessionInner("RemoteCast", AVSession::SESSION_TYPE_AUDIO, false, elementName);
643 EXPECT_EQ(avsessionHere_ != nullptr, true);
644 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
645 SLOGI("ReleaseCastSession001 in!");
646 avservice_->ReleaseCastSession();
647 #endif
648 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
649 EXPECT_EQ(0, AVSESSION_SUCCESS);
650 SLOGI("ReleaseCastSession001 end!");
651 }
652
653 static HWTEST_F(AVSessionServiceTest, CreateSessionByCast001, TestSize.Level1)
654 {
655 SLOGI("CreateSessionByCast001 begin!");
656 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
657 SLOGI("CreateSessionByCast001 in!");
658 avservice_->CreateSessionByCast(0);
659 avservice_->ClearSessionForClientDiedNoLock(getpid(), false);
660 #endif
661 EXPECT_EQ(0, AVSESSION_SUCCESS);
662 SLOGI("CreateSessionByCast001 end!");
663 }
664
665 static HWTEST_F(AVSessionServiceTest, MirrorToStreamCast001, TestSize.Level1)
666 {
667 SLOGI("MirrorToStreamCast001 begin!");
668 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
669 SLOGI("MirrorToStreamCast001 in!");
670 OHOS::AppExecFwk::ElementName elementName;
671 elementName.SetBundleName(g_testAnotherBundleName);
672 elementName.SetAbilityName(g_testAnotherAbilityName);
673 OHOS::sptr<AVSessionItem> avsessionHere_ =
674 avservice_->CreateSessionInner("RemoteCast", AVSession::SESSION_TYPE_AUDIO, false, elementName);
675 EXPECT_EQ(avsessionHere_ != nullptr, true);
676 avservice_->is2in1_ = true;
677 avservice_->MirrorToStreamCast(avsessionHere_);
678 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
679 #endif
680 EXPECT_EQ(0, AVSESSION_SUCCESS);
681 SLOGI("MirrorToStreamCast001 end!");
682 }
683
684 static HWTEST_F(AVSessionServiceTest, MirrorToStreamCast002, TestSize.Level1)
685 {
686 SLOGI("MirrorToStreamCast002 begin!");
687 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
688 SLOGI("MirrorToStreamCast002 in!");
689 OHOS::AppExecFwk::ElementName elementName;
690 elementName.SetBundleName(g_testAnotherBundleName);
691 elementName.SetAbilityName(g_testAnotherAbilityName);
692 OHOS::sptr<AVSessionItem> avsessionHere_ =
693 avservice_->CreateSessionInner("RemoteCast", AVSession::SESSION_TYPE_AUDIO, false, elementName);
694 EXPECT_EQ(avsessionHere_ != nullptr, true);
695 avservice_->is2in1_ = false;
696 avservice_->MirrorToStreamCast(avsessionHere_);
697 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
698 #endif
699 EXPECT_EQ(0, AVSESSION_SUCCESS);
700 SLOGI("MirrorToStreamCast002 end!");
701 }
702
703 static HWTEST_F(AVSessionServiceTest, MirrorToStreamCast003, TestSize.Level1)
704 {
705 SLOGI("MirrorToStreamCast003 begin!");
706 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
707 SLOGI("MirrorToStreamCast003 in!");
708 OHOS::AppExecFwk::ElementName elementName;
709 elementName.SetBundleName(g_testAnotherBundleName);
710 elementName.SetAbilityName(g_testAnotherAbilityName);
711 OHOS::sptr<AVSessionItem> avsessionHere_ =
712 avservice_->CreateSessionInner("RemoteCast", AVSession::SESSION_TYPE_AUDIO, false, elementName);
713 EXPECT_EQ(avsessionHere_ != nullptr, true);
714 avservice_->is2in1_ = true;
715 avservice_->MirrorToStreamCast(avsessionHere_);
716 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
717 #endif
718 EXPECT_EQ(0, AVSESSION_SUCCESS);
719 SLOGI("MirrorToStreamCast003 end!");
720 }
721
722 static HWTEST_F(AVSessionServiceTest, SaveSessionInfoInFile001, TestSize.Level1)
723 {
724 SLOGI("SaveSessionInfoInFile001 begin!");
725 OHOS::AppExecFwk::ElementName elementName;
726 elementName.SetBundleName(g_testAnotherBundleName);
727 elementName.SetAbilityName(g_testAnotherAbilityName);
728 OHOS::sptr<AVSessionItem> avsessionHere_ =
729 avservice_->CreateSessionInner("RemoteCast", AVSession::SESSION_TYPE_AUDIO, false, elementName);
730 EXPECT_EQ(avsessionHere_ != nullptr, true);
731 avservice_->SaveSessionInfoInFile(avsessionHere_->GetSessionId(),
732 "audio", elementName);
733 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
734 EXPECT_EQ(0, AVSESSION_SUCCESS);
735 SLOGI("SaveSessionInfoInFile001 end!");
736 }
737
738 static HWTEST_F(AVSessionServiceTest, GetHistoricalAVQueueInfos001, TestSize.Level1)
739 {
740 SLOGI("GetHistoricalAVQueueInfos001 begin!");
741 std::vector<AVQueueInfo> avQueueInfos_;
742 avservice_->GetHistoricalAVQueueInfos(0, 0, avQueueInfos_);
743 EXPECT_EQ(0, AVSESSION_SUCCESS);
744 SLOGI("GetHistoricalAVQueueInfos001 end!");
745 }
746
747 static HWTEST_F(AVSessionServiceTest, SaveAvQueueInfo001, TestSize.Level1)
748 {
749 SLOGI("SaveAvQueueInfo001 begin!");
750 OHOS::AppExecFwk::ElementName elementName;
751 elementName.SetBundleName(g_testAnotherBundleName);
752 elementName.SetAbilityName(g_testAnotherAbilityName);
753 OHOS::sptr<AVSessionItem> avsessionHere_ =
754 avservice_->CreateSessionInner("RemoteCast", AVSession::SESSION_TYPE_AUDIO, false, elementName);
755 EXPECT_EQ(avsessionHere_ != nullptr, true);
756 AVMetaData meta = avsessionHere_->GetMetaData();
757 std::string oldContent;
758 if (!avservice_->LoadStringFromFileEx(avservice_->GetAVQueueDir(), oldContent)) {
759 SLOGE("SaveAvQueueInfo001 read avqueueinfo fail, Return!");
760 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
761 return;
762 }
763 avservice_->SaveAvQueueInfo(oldContent, g_testAnotherBundleName, meta,
764 avservice_->GetUsersManager().GetCurrentUserId());
765 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
766 EXPECT_EQ(0, AVSESSION_SUCCESS);
767 SLOGI("SaveAvQueueInfo001 end!");
768 }
769
770 static HWTEST_F(AVSessionServiceTest, AddAvQueueInfoToFile001, TestSize.Level1)
771 {
772 SLOGI("AddAvQueueInfoToFile001 begin!");
773 OHOS::AppExecFwk::ElementName elementName;
774 elementName.SetBundleName(g_testAnotherBundleName);
775 elementName.SetAbilityName(g_testAnotherAbilityName);
776 OHOS::sptr<AVSessionItem> avsessionHere_ =
777 avservice_->CreateSessionInner("RemoteCast", AVSession::SESSION_TYPE_AUDIO, false, elementName);
778 EXPECT_EQ(avsessionHere_ != nullptr, true);
779 avservice_->AddAvQueueInfoToFile(*avsessionHere_);
780 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
781 EXPECT_EQ(0, AVSESSION_SUCCESS);
782 SLOGI("AddAvQueueInfoToFile001 end!");
783 }
784
785 static HWTEST_F(AVSessionServiceTest, StartAVPlayback001, TestSize.Level1)
786 {
787 SLOGI("StartAVPlayback001 begin!");
788 avservice_->StartAVPlayback(g_testAnotherBundleName, "FAKE_ASSET_NAME");
789 EXPECT_EQ(0, AVSESSION_SUCCESS);
790 SLOGI("StartAVPlayback001 end!");
791 }
792
793 static HWTEST_F(AVSessionServiceTest, StartAVPlayback002, TestSize.Level1)
794 {
795 SLOGI("StartAVPlayback002 begin!");
796 std::string deviceId = "123";
797 avservice_->StartAVPlayback(g_testAnotherBundleName, "FAKE_ASSET_NAME", deviceId);
798 EXPECT_EQ(0, AVSESSION_SUCCESS);
799 SLOGI("StartAVPlayback002 end!");
800 }
801
802 static HWTEST_F(AVSessionServiceTest, GetSubNode001, TestSize.Level1)
803 {
804 SLOGI("GetSubNode001 begin!");
805 nlohmann::json value;
806 value["bundleName"] = g_testAnotherBundleName;
807 avservice_->GetSubNode(value, "FAKE_NAME");
808 EXPECT_EQ(0, AVSESSION_SUCCESS);
809 SLOGI("GetSubNode001 end!");
810 }
811
812 static HWTEST_F(AVSessionServiceTest, Close001, TestSize.Level1)
813 {
814 SLOGI("Close001 begin!");
815 avservice_->Close();
816 EXPECT_EQ(0, AVSESSION_SUCCESS);
817 SLOGI("Close001 end!");
818 }
819
820 static HWTEST_F(AVSessionServiceTest, DeleteHistoricalRecord001, TestSize.Level1)
821 {
822 SLOGI("DeleteHistoricalRecord001 begin!");
823 avservice_->DeleteHistoricalRecord(g_testAnotherBundleName);
824 EXPECT_EQ(0, AVSESSION_SUCCESS);
825 SLOGI("DeleteHistoricalRecord001 end!");
826 }
827
828 static HWTEST_F(AVSessionServiceTest, Dump001, TestSize.Level1)
829 {
830 SLOGI("Dump001 begin!");
831 std::vector<std::u16string> argsList;
832 avservice_->Dump(1, argsList);
833 EXPECT_EQ(0, AVSESSION_SUCCESS);
834 SLOGI("Dump001 end!");
835 }
836
837 static HWTEST_F(AVSessionServiceTest, ProcessCastAudioCommand001, TestSize.Level1)
838 {
839 SLOGI("ProcessCastAudioCommand001 begin!");
840 std::string sourceSessionInfo = "SOURCE";
841 std::string sinkSessionInfo = " SINK";
842 avservice_->ProcessCastAudioCommand(
843 OHOS::AVSession::AVSessionServiceStub::RemoteServiceCommand::COMMAND_CAST_AUDIO,
844 sourceSessionInfo, sinkSessionInfo);
845 EXPECT_EQ(0, AVSESSION_SUCCESS);
846 SLOGI("ProcessCastAudioCommand001 end!");
847 }
848
849 static HWTEST_F(AVSessionServiceTest, ProcessCastAudioCommand002, TestSize.Level1)
850 {
851 SLOGI("ProcessCastAudioCommand002 begin!");
852 std::string sourceSessionInfo = "SOURCE";
853 std::string sinkSessionInfo = " SINK";
854 avservice_->ProcessCastAudioCommand(
855 OHOS::AVSession::AVSessionServiceStub::RemoteServiceCommand::COMMAND_CANCEL_CAST_AUDIO,
856 sourceSessionInfo, sinkSessionInfo);
857 EXPECT_EQ(0, AVSESSION_SUCCESS);
858 SLOGI("ProcessCastAudioCommand002 end!");
859 }
860
861 static HWTEST_F(AVSessionServiceTest, HandleDeviceChange001, TestSize.Level1)
862 {
863 SLOGI("HandleDeviceChange001 begin!");
864 DeviceChangeAction deviceChange;
865 std::vector<std::shared_ptr<AudioDeviceDescriptor>> desc;
866 std::shared_ptr<AudioDeviceDescriptor> descriptor = std::make_shared<AudioDeviceDescriptor>();
867 descriptor->deviceType_ = OHOS::AudioStandard::DEVICE_TYPE_WIRED_HEADSET;
868 deviceChange.type = static_cast<DeviceChangeType>(0);
869 deviceChange.flag = static_cast<DeviceFlag>(0);
870 desc.push_back(descriptor);
871 avservice_->HandleDeviceChange(desc);
872 EXPECT_EQ(0, AVSESSION_SUCCESS);
873 SLOGI("HandleDeviceChange001 end!");
874 }
875
876 static HWTEST_F(AVSessionServiceTest, HandleDeviceChange002, TestSize.Level1)
877 {
878 SLOGI("HandleDeviceChange002 begin!");
879 DeviceChangeAction deviceChange;
880 std::vector<std::shared_ptr<AudioDeviceDescriptor>> audioDeviceDescriptors;
881 std::shared_ptr<AudioDeviceDescriptor> descriptor = std::make_shared<AudioDeviceDescriptor>();
882 descriptor->deviceType_ = OHOS::AudioStandard::DEVICE_TYPE_WIRED_HEADSET;
883 deviceChange.type = static_cast<DeviceChangeType>(0);
884 deviceChange.flag = static_cast<DeviceFlag>(0);
885
886 audioDeviceDescriptors.push_back(descriptor);
887 avservice_->HandleDeviceChange(audioDeviceDescriptors);
888 EXPECT_EQ(0, AVSESSION_SUCCESS);
889 SLOGI("HandleDeviceChange002 end!");
890 }
891
892 static HWTEST_F(AVSessionServiceTest, OnReceiveEvent001, TestSize.Level1)
893 {
894 SLOGI("OnReceiveEvent001 begin!");
895 OHOS::EventFwk::CommonEventData eventData;
896 string action = OHOS::EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_ON;
897 OHOS::AAFwk::Want want = eventData.GetWant();
898 want.SetAction(action);
899 eventData.SetWant(want);
900 OHOS::EventFwk::MatchingSkills matchingSkills;
901 OHOS::EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
902 EventSubscriber eventSubscriber(subscriberInfo, avservice_);
903 eventSubscriber.OnReceiveEvent(eventData);
904 EXPECT_EQ(0, AVSESSION_SUCCESS);
905 SLOGI("OnReceiveEvent001 end!");
906 }
907
908 static HWTEST_F(AVSessionServiceTest, OnReceiveEvent002, TestSize.Level1)
909 {
910 SLOGI("OnReceiveEvent002 begin!");
911 OHOS::EventFwk::CommonEventData eventData;
912 string action = OHOS::EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_OFF;
913 OHOS::AAFwk::Want want = eventData.GetWant();
914 want.SetAction(action);
915 eventData.SetWant(want);
916 OHOS::EventFwk::MatchingSkills matchingSkills;
917 OHOS::EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
918 EventSubscriber eventSubscriber(subscriberInfo, avservice_);
919 eventSubscriber.OnReceiveEvent(eventData);
920 EXPECT_EQ(0, AVSESSION_SUCCESS);
921 SLOGI("OnReceiveEvent002 end!");
922 }
923
924 static HWTEST_F(AVSessionServiceTest, UnSubscribeCommonEvent001, TestSize.Level1)
925 {
926 SLOGI("SubscribeCommonEvent001 begin!");
927 EXPECT_TRUE(avservice_ != nullptr);
928 avservice_->SubscribeCommonEvent();
929 avservice_->UnSubscribeCommonEvent();
930 SLOGI("SubscribeCommonEvent001 end!");
931 }
932
933 static HWTEST_F(AVSessionServiceTest, UnSubscribeCommonEvent002, TestSize.Level1)
934 {
935 SLOGI("SubscribeCommonEvent002 begin!");
936 EXPECT_TRUE(avservice_ != nullptr);
937 avservice_->UnSubscribeCommonEvent();
938 SLOGI("SubscribeCommonEvent002 end!");
939 }
940
941 static HWTEST_F(AVSessionServiceTest, OnRemoveSystemAbility001, TestSize.Level1)
942 {
943 SLOGI("OnRemoveSystemAbility001 begin!");
944 EXPECT_TRUE(avservice_ != nullptr);
945 int32_t systemAbilityId = 65546;
946 std::string deviceId = "";
947 avservice_->OnRemoveSystemAbility(systemAbilityId, deviceId);
948 SLOGI("OnRemoveSystemAbility001 end!");
949 }
950
951 static HWTEST_F(AVSessionServiceTest, OnRemoveSystemAbility002, TestSize.Level1)
952 {
953 SLOGI("OnRemoveSystemAbility002 begin!");
954 EXPECT_TRUE(avservice_ != nullptr);
955 int32_t systemAbilityId = 111222;
956 std::string deviceId = "";
957 avservice_->OnRemoveSystemAbility(systemAbilityId, deviceId);
958 SLOGI("OnRemoveSystemAbility002 end!");
959 }
960
961 static HWTEST_F(AVSessionServiceTest, GetHistoricalSessionDescriptorsFromFile001, TestSize.Level1)
962 {
963 SLOGI("GetHistoricalSessionDescriptorsFromFile001 begin!");
964 std::vector<AVSessionDescriptor> descriptors;
965 int32_t ret = avservice_->GetHistoricalSessionDescriptorsFromFile(descriptors);
966 EXPECT_EQ(ret, AVSESSION_SUCCESS);
967 SLOGI("GetHistoricalSessionDescriptorsFromFile001 end!");
968 }
969
970 static HWTEST_F(AVSessionServiceTest, GetHistoricalSessionDescriptors001, TestSize.Level1)
971 {
972 SLOGI("GetHistoricalSessionDescriptors001 begin!");
973 int32_t maxSize = -1;
974 std::vector<AVSessionDescriptor> descriptors;
975 int32_t ret = avservice_->GetHistoricalSessionDescriptors(maxSize, descriptors);
976 EXPECT_EQ(ret, AVSESSION_SUCCESS);
977 SLOGI("GetHistoricalSessionDescriptors001 end!");
978 }
979
980 static HWTEST_F(AVSessionServiceTest, GetHistoricalSessionDescriptors002, TestSize.Level1)
981 {
982 SLOGI("GetHistoricalSessionDescriptors002 begin!");
983 int32_t maxSize = 50;
984 std::vector<AVSessionDescriptor> descriptors;
985 int32_t ret = avservice_->GetHistoricalSessionDescriptors(maxSize, descriptors);
986 EXPECT_EQ(ret, AVSESSION_SUCCESS);
987 SLOGI("GetHistoricalSessionDescriptors002 end!");
988 }
989
990 static HWTEST_F(AVSessionServiceTest, GetHistoricalSessionDescriptors003, TestSize.Level1)
991 {
992 SLOGI("GetHistoricalSessionDescriptors003 begin!");
993 int32_t maxSize = 10;
994 std::vector<AVSessionDescriptor> descriptors;
995 for (int i = 0; i <= maxSize; i++) {
996 AVSessionDescriptor aVSessionDescriptor;
997 descriptors.emplace_back(aVSessionDescriptor);
998 }
999 int32_t ret = avservice_->GetHistoricalSessionDescriptors(maxSize, descriptors);
1000 EXPECT_EQ(ret, AVSESSION_SUCCESS);
1001 SLOGI("GetHistoricalSessionDescriptors003 end!");
1002 }
1003
1004 static HWTEST_F(AVSessionServiceTest, DoMetadataImgClean001, TestSize.Level1)
1005 {
1006 SLOGI("DoMetadataImgClean001 begin!");
1007 EXPECT_TRUE(avservice_ != nullptr);
1008 OHOS::AVSession::AVMetaData metaData;
1009
1010 std::shared_ptr<AVSessionPixelMap> avQueuePixelMap = std::make_shared<AVSessionPixelMap>();
1011 std::vector<uint8_t> imgBuffer = {1, 1, 0, 1, 1};
1012 avQueuePixelMap->SetInnerImgBuffer(imgBuffer);
1013 metaData.SetAVQueueImage(avQueuePixelMap);
1014
1015 std::shared_ptr<AVSessionPixelMap> mediaPixelMap = std::make_shared<AVSessionPixelMap>();
1016 std::vector<uint8_t> imgBuffer2 = {1, 0, 0, 0, 1};
1017 mediaPixelMap->SetInnerImgBuffer(imgBuffer2);
1018 metaData.SetMediaImage(mediaPixelMap);
1019
1020 avservice_->DoMetadataImgClean(metaData);
1021 SLOGI("DoMetadataImgClean001 end!");
1022 }
1023
1024 static HWTEST_F(AVSessionServiceTest, DoMetadataImgClean002, TestSize.Level1)
1025 {
1026 SLOGI("DoMetadataImgClean002 begin!");
1027 EXPECT_TRUE(avservice_ != nullptr);
1028 OHOS::AVSession::AVMetaData metaData;
1029 avservice_->DoMetadataImgClean(metaData);
1030 SLOGI("DoMetadataImgClean002 end!");
1031 }
1032
1033 static HWTEST_F(AVSessionServiceTest, Dump002, TestSize.Level1)
1034 {
1035 SLOGI("Dump002 begin!");
1036 int32_t fd = -1;
1037 std::vector<std::u16string> argsList;
1038 int32_t ret = avservice_->Dump(fd, argsList);
1039 EXPECT_EQ(ret, ERR_INVALID_PARAM);
1040 SLOGI("Dump002 end!");
1041 }
1042
1043 static HWTEST_F(AVSessionServiceTest, GetTrustedDeviceName001, TestSize.Level1)
1044 {
1045 SLOGI("GetTrustedDeviceName001 begin!");
1046 std::string networkId = "";
1047 std::string deviceName = "";
1048 int32_t ret = avservice_->GetTrustedDeviceName(networkId, deviceName);
1049 EXPECT_EQ(ret, AVSESSION_SUCCESS);
1050 SLOGI("GetTrustedDeviceName001 end!");
1051 }
1052
1053 static HWTEST_F(AVSessionServiceTest, HandleFocusSession001, TestSize.Level1)
1054 {
1055 SLOGI("HandleFocusSession001 begin!");
1056 EXPECT_TRUE(avservice_ != nullptr);
1057 int32_t pid = 201;
1058 OHOS::AppExecFwk::ElementName elementName;
1059 elementName.SetBundleName(g_testAnotherBundleName);
1060 elementName.SetAbilityName(g_testAnotherAbilityName);
1061 OHOS::sptr<AVSessionItem> avsessionHere_ =
1062 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
1063 avsessionHere_->SetUid(pid);
1064 avservice_->UpdateTopSession(avsessionHere_);
1065 FocusSessionStrategy::FocusSessionChangeInfo info;
1066 info.uid = pid;
1067 avservice_->HandleFocusSession(info, false);
1068 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
1069 avsessionHere_->Destroy();
1070 SLOGI("HandleFocusSession001 end!");
1071 }
1072
1073 static HWTEST_F(AVSessionServiceTest, HandleFocusSession002, TestSize.Level1)
1074 {
1075 SLOGI("HandleFocusSession002 begin!");
1076 EXPECT_TRUE(avservice_ != nullptr);
1077 int32_t pid = 202;
1078 OHOS::AppExecFwk::ElementName elementName;
1079 elementName.SetBundleName(g_testAnotherBundleName);
1080 elementName.SetAbilityName(g_testAnotherAbilityName);
1081 OHOS::sptr<AVSessionItem> avsessionHere_ =
1082 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_VOICE_CALL, false, elementName);
1083 avsessionHere_->SetUid(pid);
1084 avservice_->UpdateTopSession(avsessionHere_);
1085 FocusSessionStrategy::FocusSessionChangeInfo info;
1086 info.uid = 203;
1087 avservice_->HandleFocusSession(info, false);
1088 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
1089 avsessionHere_->Destroy();
1090 SLOGI("HandleFocusSession002 end!");
1091 }
1092
1093 static HWTEST_F(AVSessionServiceTest, UpdateFrontSession001, TestSize.Level1)
1094 {
1095 SLOGI("HandleFocusSession001 begin!");
1096 EXPECT_TRUE(avservice_ != nullptr);
1097 int32_t pid = 203;
1098 OHOS::AppExecFwk::ElementName elementName;
1099 elementName.SetBundleName(g_testAnotherBundleName);
1100 elementName.SetAbilityName(g_testAnotherAbilityName);
1101 OHOS::sptr<AVSessionItem> avsessionHere_ =
1102 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
1103 avsessionHere_->SetUid(pid);
1104 FocusSessionStrategy::FocusSessionChangeInfo info;
1105 info.uid = pid;
1106 avservice_->HandleFocusSession(info, false);
1107 avservice_->UpdateFrontSession(avsessionHere_, true);
1108 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
1109 avsessionHere_->Destroy();
1110 SLOGI("HandleFocusSession001 end!");
1111 }
1112
1113 static HWTEST_F(AVSessionServiceTest, UpdateFrontSession002, TestSize.Level1)
1114 {
1115 SLOGI("UpdateFrontSession002 begin!");
1116 EXPECT_TRUE(avservice_ != nullptr);
1117 int32_t pid = 204;
1118 OHOS::AppExecFwk::ElementName elementName;
1119 elementName.SetBundleName(g_testAnotherBundleName);
1120 elementName.SetAbilityName(g_testAnotherAbilityName);
1121 OHOS::sptr<AVSessionItem> avsessionHere_ =
1122 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
1123 avsessionHere_->SetUid(pid);
1124 FocusSessionStrategy::FocusSessionChangeInfo info;
1125 info.uid = 205;
1126 avservice_->HandleFocusSession(info, false);
1127 avservice_->UpdateFrontSession(avsessionHere_, true);
1128 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
1129 avsessionHere_->Destroy();
1130 SLOGI("UpdateFrontSession002 end!");
1131 }
1132
1133 static HWTEST_F(AVSessionServiceTest, SelectFocusSession001, TestSize.Level1)
1134 {
1135 SLOGI("SelectFocusSession001 begin!");
1136 int32_t pid = 205;
1137 OHOS::AppExecFwk::ElementName elementName;
1138 elementName.SetBundleName(g_testAnotherBundleName);
1139 elementName.SetAbilityName(g_testAnotherAbilityName);
1140 OHOS::sptr<AVSessionItem> avsessionHere_ =
1141 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
1142 avsessionHere_->SetUid(pid);
1143 FocusSessionStrategy::FocusSessionChangeInfo info;
1144 info.uid = pid;
1145 bool ret = avservice_->SelectFocusSession(info);
1146 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
1147 avsessionHere_->Destroy();
1148 EXPECT_EQ(ret, true);
1149 SLOGI("SelectFocusSession001 end!");
1150 }
1151
1152 static HWTEST_F(AVSessionServiceTest, SelectFocusSession002, TestSize.Level1)
1153 {
1154 SLOGI("SelectFocusSession002 begin!");
1155 int32_t pid = 206;
1156 OHOS::AppExecFwk::ElementName elementName;
1157 elementName.SetBundleName(g_testAnotherBundleName);
1158 elementName.SetAbilityName(g_testAnotherAbilityName);
1159 OHOS::sptr<AVSessionItem> avsessionHere_ =
1160 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
1161 avsessionHere_->SetUid(pid);
1162 FocusSessionStrategy::FocusSessionChangeInfo info;
1163 info.uid = 207;
1164 bool ret = avservice_->SelectFocusSession(info);
1165 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
1166 avsessionHere_->Destroy();
1167 EXPECT_EQ(ret, false);
1168 SLOGI("SelectFocusSession002 end!");
1169 }
1170
1171 static HWTEST_F(AVSessionServiceTest, SelectSessionByUid003, TestSize.Level1)
1172 {
1173 SLOGI("SelectSessionByUid003 begin!");
1174 int32_t pid = 207;
1175 OHOS::AppExecFwk::ElementName elementName;
1176 elementName.SetBundleName(g_testAnotherBundleName);
1177 elementName.SetAbilityName(g_testAnotherAbilityName);
1178 OHOS::sptr<AVSessionItem> avsessionHere_ =
1179 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
1180 EXPECT_EQ(avsessionHere_ != nullptr, true);
1181 avsessionHere_->SetUid(pid);
1182 AudioRendererChangeInfo info = {};
1183 info.clientUID = 208;
1184 auto ret = avservice_->SelectSessionByUid(info);
1185 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
1186 avsessionHere_->Destroy();
1187 EXPECT_EQ(ret, nullptr);
1188 SLOGI("SelectSessionByUid003 end!");
1189 }
1190
1191 static HWTEST_F(AVSessionServiceTest, GetSessionDescriptorsBySessionId001, TestSize.Level1)
1192 {
1193 SLOGI("GetSessionDescriptorsBySessionId001 begin!");
1194 int32_t pid = 206;
1195 OHOS::AppExecFwk::ElementName elementName;
1196 elementName.SetBundleName(g_testAnotherBundleName);
1197 elementName.SetAbilityName(g_testAnotherAbilityName);
1198 OHOS::sptr<AVSessionItem> avsessionHere_ =
1199 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
1200 avsessionHere_->SetUid(pid);
1201 std::string sessionId = "";
1202 AVSessionDescriptor descriptor;
1203 int32_t ret = avservice_->GetSessionDescriptorsBySessionId(sessionId, descriptor);
1204 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
1205 avsessionHere_->Destroy();
1206 EXPECT_EQ(ret, AVSESSION_ERROR);
1207 SLOGI("GetSessionDescriptorsBySessionId001 end!");
1208 }
1209
1210 static HWTEST_F(AVSessionServiceTest, SendSystemAVKeyEvent007, TestSize.Level1)
1211 {
1212 SLOGI("SendSystemAVKeyEvent007 begin!");
1213 OHOS::AppExecFwk::ElementName elementName;
1214 elementName.SetBundleName(g_testAnotherBundleName);
1215 elementName.SetAbilityName(g_testAnotherAbilityName);
1216 OHOS::sptr<AVSessionItem> avsessionHere_ =
1217 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_VOICE_CALL, false, elementName);
1218 auto keyEvent = OHOS::MMI::KeyEvent::Create();
1219 ASSERT_NE(keyEvent, nullptr);
1220 bool ret = avservice_->SendSystemAVKeyEvent(*keyEvent);
1221 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
1222 avsessionHere_->Destroy();
1223 EXPECT_EQ(ret, AVSESSION_SUCCESS);
1224 SLOGI("SendSystemAVKeyEvent007 end!");
1225 }
1226
1227
1228 static HWTEST_F(AVSessionServiceTest, SendSystemAVKeyEvent008, TestSize.Level1)
1229 {
1230 SLOGI("SendSystemAVKeyEvent008 begin!");
1231 OHOS::AppExecFwk::ElementName elementName;
1232 elementName.SetBundleName(g_testAnotherBundleName);
1233 elementName.SetAbilityName(g_testAnotherAbilityName);
1234 OHOS::sptr<AVSessionItem> avsessionHere_ =
1235 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
1236 auto keyEvent = OHOS::MMI::KeyEvent::Create();
1237 ASSERT_NE(keyEvent, nullptr);
1238 avservice_->UpdateTopSession(avsessionHere_);
1239 bool ret = avservice_->SendSystemAVKeyEvent(*keyEvent);
1240 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
1241 avsessionHere_->Destroy();
1242 EXPECT_EQ(ret, AVSESSION_SUCCESS);
1243 SLOGI("SendSystemAVKeyEvent008 end!");
1244 }
1245
1246 static HWTEST_F(AVSessionServiceTest, SendSystemAVKeyEvent009, TestSize.Level1)
1247 {
1248 SLOGI("SendSystemAVKeyEvent009 begin!");
1249 OHOS::AppExecFwk::ElementName elementName;
1250 elementName.SetBundleName(g_testAnotherBundleName);
1251 elementName.SetAbilityName(g_testAnotherAbilityName);
1252 OHOS::sptr<AVSessionItem> avsessionHere_ =
1253 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
1254 auto keyEvent = OHOS::MMI::KeyEvent::Create();
1255 ASSERT_NE(keyEvent, nullptr);
1256 OHOS::AAFwk::Want bluetoothWant;
1257 std::string activeAddress = "00:00:00:00:00:00";
1258 bluetoothWant.SetParam("deviceId", activeAddress);
1259 bool ret = avservice_->SendSystemAVKeyEvent(*keyEvent, bluetoothWant);
1260 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
1261 avsessionHere_->Destroy();
1262 EXPECT_EQ(ret, AVSESSION_SUCCESS);
1263 SLOGI("SendSystemAVKeyEvent009 end!");
1264 }
1265
1266 static HWTEST_F(AVSessionServiceTest, PullMigrateStub001, TestSize.Level1)
1267 {
1268 SLOGI("PullMigrateStub001 begin!");
1269 EXPECT_TRUE(avservice_ != nullptr);
1270 avservice_->PullMigrateStub();
1271 SLOGI("PullMigrateStub001 end!");
1272 }
1273
1274 static HWTEST_F(AVSessionServiceTest, UpdateFrontSession003, TestSize.Level1)
1275 {
1276 SLOGI("UpdateFrontSession003 begin!");
1277 EXPECT_TRUE(avservice_ != nullptr);
1278 int32_t pid = 304;
1279 OHOS::AppExecFwk::ElementName elementName;
1280 elementName.SetBundleName(g_testAnotherBundleName);
1281 elementName.SetAbilityName(g_testAnotherAbilityName);
1282 OHOS::sptr<AVSessionItem> avsessionHere_ =
1283 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_VOICE_CALL, false, elementName);
1284 avsessionHere_->SetUid(pid);
1285 avservice_->UpdateFrontSession(avsessionHere_, true);
1286 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
1287 avsessionHere_->Destroy();
1288 SLOGI("UpdateFrontSession003 end!");
1289 }
1290
1291 static HWTEST_F(AVSessionServiceTest, CreateSessionInner001, TestSize.Level1)
1292 {
1293 SLOGI("CreateSessionInner001 begin!");
1294 OHOS::sptr<AVSessionItem> sessionItem = nullptr;
1295 OHOS::AppExecFwk::ElementName elementName;
1296 elementName.SetBundleName("######");
1297 elementName.SetAbilityName(g_testAnotherAbilityName);
1298 int32_t ret = avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO,
1299 false, elementName, sessionItem);
1300 EXPECT_EQ(ret, ERR_INVALID_PARAM);
1301 SLOGI("CreateSessionInner001 end!");
1302 }
1303
1304 static HWTEST_F(AVSessionServiceTest, CreateSessionInner002, TestSize.Level1)
1305 {
1306 SLOGI("CreateSessionInner001 begin!");
1307 OHOS::sptr<AVSessionItem> sessionItem = nullptr;
1308 OHOS::AppExecFwk::ElementName elementName;
1309 elementName.SetBundleName(g_testAnotherBundleName);
1310 elementName.SetAbilityName("######");
1311 int32_t ret = avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO,
1312 false, elementName, sessionItem);
1313 EXPECT_EQ(ret, ERR_INVALID_PARAM);
1314 SLOGI("CreateSessionInner001 end!");
1315 }
1316
1317 static HWTEST_F(AVSessionServiceTest, ReportSessionInfo001, TestSize.Level1)
1318 {
1319 SLOGI("ReportSessionInfo001 begin!");
1320 EXPECT_TRUE(avservice_ != nullptr);
1321 OHOS::sptr<AVSessionItem> avsessionHere_ = nullptr;
1322 avservice_->ReportSessionInfo(avsessionHere_, true);
1323 SLOGI("ReportSessionInfo001 end!");
1324 }
1325
1326 static HWTEST_F(AVSessionServiceTest, CreateNewControllerForSession001, TestSize.Level1)
1327 {
1328 SLOGI("CreateNewControllerForSession001 begin!");
1329 OHOS::AppExecFwk::ElementName elementName;
1330 elementName.SetBundleName(g_testAnotherBundleName);
1331 elementName.SetAbilityName(g_testAnotherAbilityName);
1332 OHOS::sptr<AVSessionItem> avsessionHere_ =
1333 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_VOICE_CALL, false, elementName);
1334 pid_t pid = 2222;
1335 auto ret = avservice_->CreateNewControllerForSession(pid, avsessionHere_);
1336 EXPECT_NE(ret, nullptr);
1337 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
1338 avsessionHere_->Destroy();
1339 SLOGI("CreateNewControllerForSession001 end!");
1340 }
1341
1342 static HWTEST_F(AVSessionServiceTest, IsHistoricalSession001, TestSize.Level1)
1343 {
1344 SLOGI("IsHistoricalSession001 begin!");
1345 OHOS::AppExecFwk::ElementName elementName;
1346 elementName.SetBundleName(g_testAnotherBundleName);
1347 elementName.SetAbilityName(g_testAnotherAbilityName);
1348 OHOS::sptr<AVSessionItem> avsessionHere_ =
1349 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
1350 std::string sessionId = avsessionHere_->GetSessionId();
1351 bool ret = avservice_->IsHistoricalSession(sessionId);
1352 EXPECT_EQ(ret, false);
1353 avservice_->HandleSessionRelease(sessionId);
1354 avsessionHere_->Destroy();
1355 SLOGI("IsHistoricalSession001 end!");
1356 }
1357
1358 static HWTEST_F(AVSessionServiceTest, StartDefaultAbilityByCall001, TestSize.Level1)
1359 {
1360 SLOGI("StartDefaultAbilityByCall001 begin!");
1361 OHOS::AppExecFwk::ElementName elementName;
1362 elementName.SetBundleName(g_testAnotherBundleName);
1363 elementName.SetAbilityName(g_testAnotherAbilityName);
1364 OHOS::sptr<AVSessionItem> avsessionHere_ =
1365 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
1366 std::string sessionId = avsessionHere_->GetSessionId();
1367 int32_t ret = avservice_->StartDefaultAbilityByCall(sessionId);
1368 // startability may go with mediaintent, will return AVSESSION_ERROR
1369 EXPECT_EQ(ret == ERR_ABILITY_NOT_AVAILABLE || ret == AVSESSION_SUCCESS ||
1370 ret == AVSESSION_ERROR || ret == ERR_START_ABILITY_TIMEOUT, true);
1371 avservice_->HandleSessionRelease(sessionId);
1372 avsessionHere_->Destroy();
1373 SLOGI("StartDefaultAbilityByCall001 end!");
1374 }
1375
1376 static HWTEST_F(AVSessionServiceTest, StartAbilityByCall001, TestSize.Level1)
1377 {
1378 SLOGI("StartAbilityByCall001 begin!");
1379 OHOS::AppExecFwk::ElementName elementName;
1380 elementName.SetBundleName(g_testAnotherBundleName);
1381 elementName.SetAbilityName(g_testAnotherAbilityName);
1382 OHOS::sptr<AVSessionItem> avsessionHere_ =
1383 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
1384 std::string sessionIdNeeded = "";
1385 std::string sessionId = "";
1386 int32_t ret = avservice_->StartAbilityByCall(sessionIdNeeded, sessionId);
1387 EXPECT_EQ(ret, AVSESSION_ERROR);
1388 avsessionHere_->Destroy();
1389 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
1390 SLOGI("StartAbilityByCall001 end!");
1391 }
1392
1393 static HWTEST_F(AVSessionServiceTest, HandleSystemKeyColdStart001, TestSize.Level1)
1394 {
1395 SLOGI("HandleSystemKeyColdStart001 begin!");
1396 EXPECT_TRUE(avservice_ != nullptr);
1397 OHOS::AppExecFwk::ElementName elementName;
1398 elementName.SetBundleName(g_testAnotherBundleName);
1399 elementName.SetAbilityName(g_testAnotherAbilityName);
1400 OHOS::sptr<AVSessionItem> avsessionHere_ =
1401 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
1402 AVControlCommand command;
1403 avservice_->HandleSystemKeyColdStart(command);
1404 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
1405 avsessionHere_->Destroy();
1406 SLOGI("HandleSystemKeyColdStart001 end!");
1407 }
1408
1409 static HWTEST_F(AVSessionServiceTest, SendSystemControlCommand001, TestSize.Level1)
1410 {
1411 SLOGI("SendSystemControlCommand001 begin!");
1412 OHOS::AppExecFwk::ElementName elementName;
1413 elementName.SetBundleName(g_testAnotherBundleName);
1414 elementName.SetAbilityName(g_testAnotherAbilityName);
1415 OHOS::sptr<AVSessionItem> avsessionHere_ =
1416 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
1417 avservice_->UpdateFrontSession(avsessionHere_, true);
1418 AVControlCommand command;
1419 command.SetCommand(1000);
1420 int32_t ret = avservice_->SendSystemControlCommand(command);
1421 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
1422 avsessionHere_->Destroy();
1423 EXPECT_EQ(ret, AVSESSION_SUCCESS);
1424 SLOGI("SendSystemControlCommand001 end!");
1425 }
1426
1427 static HWTEST_F(AVSessionServiceTest, HandleControllerRelease001, TestSize.Level1)
1428 {
1429 SLOGI("HandleControllerRelease001 begin!");
1430 EXPECT_TRUE(avservice_ != nullptr);
1431 OHOS::AppExecFwk::ElementName elementName;
1432 elementName.SetBundleName(g_testAnotherBundleName);
1433 elementName.SetAbilityName(g_testAnotherAbilityName);
1434 OHOS::sptr<AVSessionItem> avsessionHere_ =
1435 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_VOICE_CALL, false, elementName);
1436 OHOS::sptr<AVControllerItem> avcontrollerHere_ =
1437 avservice_->CreateNewControllerForSession(avsessionHere_->GetPid(), avsessionHere_);
1438 avservice_->HandleControllerRelease(*avcontrollerHere_);
1439 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
1440 avsessionHere_->Destroy();
1441 SLOGI("HandleControllerRelease001 end!");
1442 }
1443
1444 static HWTEST_F(AVSessionServiceTest, GetDeviceInfo001, TestSize.Level1)
1445 {
1446 SLOGI("GetDeviceInfo001 begin!");
1447 EXPECT_TRUE(avservice_ != nullptr);
1448 OHOS::AppExecFwk::ElementName elementName;
1449 elementName.SetBundleName(g_testAnotherBundleName);
1450 elementName.SetAbilityName(g_testAnotherAbilityName);
1451 OHOS::sptr<AVSessionItem> avsessionHere_ =
1452 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_VOICE_CALL, false, elementName);
1453 std::vector<OHOS::AudioStandard::AudioDeviceDescriptor> descriptors;
1454 avservice_->GetDeviceInfo(avsessionHere_, descriptors, descriptors, descriptors);
1455 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
1456 avsessionHere_->Destroy();
1457 SLOGI("GetDeviceInfo001 end!");
1458 }
1459
1460 static HWTEST_F(AVSessionServiceTest, CreateControllerInner001, TestSize.Level1)
1461 {
1462 SLOGI("CreateControllerInner001 begin!");
1463 std::string sessionId = "default";
1464 OHOS::sptr<IRemoteObject> object = nullptr;
1465 int32_t ret = avservice_->CreateControllerInner(sessionId, object);
1466 // not support default any more for cold start logic refresh
1467 EXPECT_EQ(ret == ERR_ABILITY_NOT_AVAILABLE || ret == AVSESSION_SUCCESS
1468 || ret == AVSESSION_ERROR || ret == ERR_SESSION_NOT_EXIST, true);
1469 SLOGI("CreateControllerInner001 end!");
1470 }
1471
1472 static HWTEST_F(AVSessionServiceTest, ClearControllerForClientDiedNoLock001, TestSize.Level1)
1473 {
1474 SLOGI("ClearControllerForClientDiedNoLock001 begin!");
1475 EXPECT_TRUE(avservice_ != nullptr);
1476 OHOS::AppExecFwk::ElementName elementName;
1477 elementName.SetBundleName(g_testAnotherBundleName);
1478 elementName.SetAbilityName(g_testAnotherAbilityName);
1479 OHOS::sptr<AVSessionItem> avsessionHere_ =
1480 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_VOICE_CALL, false, elementName);
1481 std::string sessionId = avsessionHere_->GetSessionId();
1482 OHOS::sptr<IRemoteObject> object = nullptr;
1483 int32_t ret = avservice_->CreateControllerInner(sessionId, object);
1484 ASSERT_EQ(ret, AVSESSION_SUCCESS);
1485 avservice_->ClearControllerForClientDiedNoLock(avsessionHere_->GetPid());
1486 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
1487 avsessionHere_->Destroy();
1488 SLOGI("ClearControllerForClientDiedNoLock001 end!");
1489 }
1490
1491 static HWTEST_F(AVSessionServiceTest, LoadStringFromFileEx001, TestSize.Level1)
1492 {
1493 SLOGI("LoadStringFromFileEx001 begin!");
1494 OHOS::AppExecFwk::ElementName elementName;
1495 elementName.SetBundleName(g_testAnotherBundleName);
1496 elementName.SetAbilityName(g_testAnotherAbilityName);
1497 OHOS::sptr<AVSessionItem> avsessionHere_ =
1498 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
1499 EXPECT_EQ(avsessionHere_ != nullptr, true);
1500
1501 std::string filePath = avservice_->GetUsersManager().GetDirForCurrentUser() + "test1.txt";
1502 std::string content;
1503 bool ret = avservice_->LoadStringFromFileEx(filePath, content);
1504 EXPECT_EQ(ret, true);
1505 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
1506 avsessionHere_->Destroy();
1507 SLOGI("LoadStringFromFileEx001 end!");
1508 }
1509
1510 static HWTEST_F(AVSessionServiceTest, LoadStringFromFileEx002, TestSize.Level1)
1511 {
1512 SLOGI("LoadStringFromFileEx002 begin!");
1513 OHOS::AppExecFwk::ElementName elementName;
1514 elementName.SetBundleName(g_testAnotherBundleName);
1515 elementName.SetAbilityName(g_testAnotherAbilityName);
1516 OHOS::sptr<AVSessionItem> avsessionHere_ =
1517 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
1518 EXPECT_EQ(avsessionHere_ != nullptr, true);
1519 int32_t maxFileLength = 32 * 1024 * 1024;
1520 std::string filePath = avservice_->GetUsersManager().GetDirForCurrentUser() + "test2.txt";
1521 std::ofstream ofs;
1522 ofs.open(filePath, std::ios::out);
1523 for (int32_t i = 0; i <= maxFileLength; i++) {
1524 ofs << "A";
1525 }
1526 ofs.close();
1527 std::string content;
1528 bool ret = avservice_->LoadStringFromFileEx(filePath, content);
1529 EXPECT_EQ(ret, false);
1530 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
1531 avsessionHere_->Destroy();
1532 SLOGI("LoadStringFromFileEx002 end!");
1533 }
1534
1535 static HWTEST_F(AVSessionServiceTest, LoadStringFromFileEx003, TestSize.Level1)
1536 {
1537 SLOGI("LoadStringFromFileEx003 begin!");
1538 OHOS::AppExecFwk::ElementName elementName;
1539 elementName.SetBundleName(g_testAnotherBundleName);
1540 elementName.SetAbilityName(g_testAnotherAbilityName);
1541 OHOS::sptr<AVSessionItem> avsessionHere_ =
1542 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
1543 EXPECT_EQ(avsessionHere_ != nullptr, true);
1544
1545 std::string filePath = "/test3.txt";
1546 std::string content;
1547 std::ifstream file(filePath, std::ios_base::in);
1548 bool ret = avservice_->LoadStringFromFileEx(filePath, content);
1549 file.close();
1550 SLOGI("LoadStringFromFileEx003 check ret:%{public}d", static_cast<int>(ret));
1551 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
1552 avsessionHere_->Destroy();
1553 SLOGI("LoadStringFromFileEx003 end!");
1554 }
1555
1556 static HWTEST_F(AVSessionServiceTest, CheckStringAndCleanFile001, TestSize.Level1)
1557 {
1558 SLOGI("CheckStringAndCleanFile001 begin!");
1559 OHOS::AppExecFwk::ElementName elementName;
1560 elementName.SetBundleName(g_testAnotherBundleName);
1561 elementName.SetAbilityName(g_testAnotherAbilityName);
1562 OHOS::sptr<AVSessionItem> avsessionHere_ =
1563 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
1564 EXPECT_EQ(avsessionHere_ != nullptr, true);
1565
1566 std::string filePath = avservice_->GetUsersManager().GetDirForCurrentUser() + "test6.txt";
1567 bool ret = avservice_->CheckStringAndCleanFile(filePath);
1568 EXPECT_EQ(ret, true);
1569 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
1570 avsessionHere_->Destroy();
1571 SLOGI("CheckStringAndCleanFile001 end!");
1572 }
1573
1574 static HWTEST_F(AVSessionServiceTest, CheckStringAndCleanFile002, TestSize.Level1)
1575 {
1576 SLOGI("CheckStringAndCleanFile002 begin!");
1577 OHOS::AppExecFwk::ElementName elementName;
1578 elementName.SetBundleName(g_testAnotherBundleName);
1579 elementName.SetAbilityName(g_testAnotherAbilityName);
1580 OHOS::sptr<AVSessionItem> avsessionHere_ =
1581 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
1582 EXPECT_EQ(avsessionHere_ != nullptr, true);
1583
1584 std::string filePath = avservice_->GetUsersManager().GetDirForCurrentUser() + "adcdXYZ123/test7.txt";
1585 std::ifstream file(filePath, std::ios_base::in);
1586 bool ret = avservice_->CheckStringAndCleanFile(filePath);
1587 file.close();
1588 // file not exist for ifstream file can not create file in non-existent folder
1589 EXPECT_EQ(ret, false);
1590 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
1591 avsessionHere_->Destroy();
1592 SLOGI("CheckStringAndCleanFile002 end!");
1593 }
1594
1595 static HWTEST_F(AVSessionServiceTest, ReportStartCastEnd001, TestSize.Level1)
1596 {
1597 SLOGI("NotifyDeviceAvailable001 begin!");
1598 OHOS::AppExecFwk::ElementName elementName;
1599 elementName.SetBundleName(g_testAnotherBundleName);
1600 elementName.SetAbilityName(g_testAnotherAbilityName);
1601 OHOS::sptr<AVSessionItem> avsessionHere_ =
1602 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
1603 EXPECT_EQ(avsessionHere_ != nullptr, true);
1604 std::string func = "";
1605 int32_t uid = avsessionHere_->GetUid();
1606 int ret = 1;
1607 OutputDeviceInfo outputDeviceInfo;
1608 OHOS::AVSession::DeviceInfo deviceInfo;
1609 deviceInfo.castCategory_ = 1;
1610 deviceInfo.deviceId_ = "deviceId";
1611 avservice_->ReportStartCastEnd(func, outputDeviceInfo, uid, ret);
1612 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
1613 avsessionHere_->Destroy();
1614 SLOGI("NotifyDeviceAvailable001 end!");
1615 }
1616
1617 static HWTEST_F(AVSessionServiceTest, OnReceiveEvent003, TestSize.Level1)
1618 {
1619 SLOGD("OnReceiveEvent003 begin!");
1620 OHOS::EventFwk::CommonEventData eventData;
1621 string action = OHOS::EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_LOCKED;
1622 OHOS::AAFwk::Want want = eventData.GetWant();
1623 want.SetAction(action);
1624 eventData.SetWant(want);
1625 OHOS::EventFwk::MatchingSkills matchingSkills;
1626 OHOS::EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
1627 EventSubscriber eventSubscriber(subscriberInfo, avservice_);
1628 eventSubscriber.OnReceiveEvent(eventData);
1629 int32_t ret = action.compare(OHOS::EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_LOCKED);
1630 EXPECT_EQ(ret, 0);
1631 SLOGD("OnReceiveEvent003 end!");
1632 }
1633
1634 static HWTEST_F(AVSessionServiceTest, UpdateFrontSession004, TestSize.Level1)
1635 {
1636 SLOGD("UpdateFrontSession004 begin!");
1637 OHOS::AppExecFwk::ElementName elementName;
1638 elementName.SetBundleName(g_testAnotherBundleName);
1639 elementName.SetAbilityName(g_testAnotherAbilityName);
1640 OHOS::sptr<AVSessionItem> avsessionHere =
1641 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_VOICE_CALL, false, elementName);
1642 EXPECT_EQ(avsessionHere != nullptr, true);
1643 avservice_->UpdateTopSession(avsessionHere);
1644 avservice_->UpdateFrontSession(avsessionHere, false);
1645 avservice_->HandleSessionRelease(avsessionHere->GetSessionId());
1646 avsessionHere->Destroy();
1647 SLOGD("UpdateFrontSession004 end!");
1648 }
1649
1650 static HWTEST_F(AVSessionServiceTest, CheckAncoAudio001, TestSize.Level1)
1651 {
1652 SLOGD("CheckAncoAudio001 begin!");
1653 OHOS::AppExecFwk::ElementName elementName;
1654 elementName.SetBundleName(g_testAnotherBundleName);
1655 elementName.SetAbilityName(g_testAnotherAbilityName);
1656 OHOS::sptr<AVSessionItem> avsessionHere =
1657 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_VOICE_CALL, false, elementName);
1658 bool ret = avservice_->CheckAncoAudio();
1659 EXPECT_EQ(ret, false);
1660 avsessionHere->Destroy();
1661 SLOGD("CheckAncoAudio001 end!");
1662 }
1663
1664 static HWTEST_F(AVSessionServiceTest, SendSystemControlCommand002, TestSize.Level1)
1665 {
1666 SLOGD("SendSystemControlCommand002 begin!");
1667 OHOS::AppExecFwk::ElementName elementName;
1668 elementName.SetBundleName(g_testAnotherBundleName);
1669 elementName.SetAbilityName(g_testAnotherAbilityName);
1670 OHOS::sptr<AVSessionItem> avsessionHere =
1671 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
1672 avservice_->UpdateTopSession(avsessionHere);
1673 AVControlCommand command;
1674 command.SetCommand(1000);
1675 int32_t ret = avservice_->SendSystemControlCommand(command);
1676 avservice_->HandleSessionRelease(avsessionHere->GetSessionId());
1677 avsessionHere->Destroy();
1678 EXPECT_EQ(ret, AVSESSION_SUCCESS);
1679 SLOGD("SendSystemControlCommand002 end!");
1680 }
1681
1682 static HWTEST_F(AVSessionServiceTest, CreateWantAgent001, TestSize.Level1)
1683 {
1684 SLOGD("CreateWantAgent001 begin!");
1685 std::shared_ptr<AVSessionDescriptor> histroyDescriptor(nullptr);
1686 auto ret = avservice_->CreateWantAgent(histroyDescriptor.get());
1687 EXPECT_EQ(ret, nullptr);
1688 SLOGD("CreateWantAgent001 end!");
1689 }
1690
1691 static HWTEST_F(AVSessionServiceTest, CreateWantAgent002, TestSize.Level1)
1692 {
1693 SLOGD("CreateWantAgent001 begin!");
1694 std::shared_ptr<AVSessionDescriptor> histroyDescriptor = std::make_shared<AVSessionDescriptor>();
1695 auto ret = avservice_->CreateWantAgent(histroyDescriptor.get());
1696 EXPECT_EQ(ret, nullptr);
1697 SLOGD("CreateWantAgent001 end!");
1698 }
1699
1700 static HWTEST_F(AVSessionServiceTest, CreateWantAgent003, TestSize.Level1)
1701 {
1702 SLOGD("CreateWantAgent003 begin!");
1703 OHOS::AppExecFwk::ElementName elementName;
1704 elementName.SetBundleName(g_testAnotherBundleName);
1705 elementName.SetAbilityName(g_testAnotherAbilityName);
1706 OHOS::sptr<AVSessionItem> avsessionHere =
1707 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
1708 avservice_->UpdateTopSession(avsessionHere);
1709 std::shared_ptr<AVSessionDescriptor> histroyDescriptor(nullptr);
1710 auto ret = avservice_->CreateWantAgent(histroyDescriptor.get());
1711 avsessionHere->Destroy();
1712 EXPECT_EQ(ret, nullptr);
1713 SLOGD("CreateWantAgent003 end!");
1714 }
1715
1716 static HWTEST_F(AVSessionServiceTest, CreateWantAgent004, TestSize.Level1)
1717 {
1718 SLOGD("CreateWantAgent004 begin!");
1719 OHOS::AppExecFwk::ElementName elementName;
1720 elementName.SetBundleName(g_testAnotherBundleName);
1721 elementName.SetAbilityName(g_testAnotherAbilityName);
1722 OHOS::sptr<AVSessionItem> avsessionHere =
1723 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
1724 avservice_->UpdateTopSession(avsessionHere);
1725 std::shared_ptr<AVSessionDescriptor> histroyDescriptor = std::make_shared<AVSessionDescriptor>();
1726 auto ret = avservice_->CreateWantAgent(histroyDescriptor.get());
1727 avsessionHere->Destroy();
1728 EXPECT_EQ(ret, nullptr);
1729 SLOGD("CreateWantAgent004 end!");
1730 }
1731
1732 static HWTEST_F(AVSessionServiceTest, HandleSystemKeyColdStart002, TestSize.Level1)
1733 {
1734 SLOGD("HandleSystemKeyColdStart002 begin!");
1735 OHOS::AppExecFwk::ElementName elementName;
1736 elementName.SetBundleName(g_testAnotherBundleName);
1737 elementName.SetAbilityName(g_testAnotherAbilityName);
1738 OHOS::sptr<AVSessionItem> avsessionHere =
1739 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
1740 EXPECT_EQ(avsessionHere != nullptr, true);
1741 AVControlCommand command;
1742 command.SetCommand(AVControlCommand::SESSION_CMD_PLAY);
1743 avservice_->HandleSystemKeyColdStart(command);
1744 avservice_->HandleSessionRelease(avsessionHere->GetSessionId());
1745 avsessionHere->Destroy();
1746 SLOGD("HandleSystemKeyColdStart002 end!");
1747 }
1748
1749 /**
1750 * @tc.name: OnIdleWithSessions001
1751 * @tc.desc: Verifying the OnIdle method with a valid idle reason.
1752 * @tc.type: FUNC
1753 * @tc.require: #I5Y4MZ
1754 */
1755 static HWTEST_F(AVSessionServiceTest, OnIdleWithSessions001, TestSize.Level1)
1756 {
1757 SLOGD("OnIdleWithSessions001 begin!");
1758 const OHOS::SystemAbilityOnDemandReason idleReason(
1759 OHOS::OnDemandReasonId::INTERFACE_CALL, "INTERFACE_CALL", "TestValue", 12345);
1760 int32_t result = avservice_->OnIdle(idleReason);
1761 EXPECT_EQ(result, 0);
1762 SLOGD("OnIdleWithSessions001 end!");
1763 }
1764
1765 /**
1766 * @tc.name: HandleRemoveMediaCardEvent001
1767 * @tc.desc: Verifying the HandleRemoveMediaCardEvent method with a valid session.
1768 * @tc.type: FUNC
1769 * @tc.require: #I5Y4MZ
1770 */
1771 static HWTEST_F(AVSessionServiceTest, HandleRemoveMediaCardEvent001, TestSize.Level1)
1772 {
1773 SLOGD("HandleRemoveMediaCardEvent001 begin!");
1774 OHOS::AppExecFwk::ElementName elementName;
1775 elementName.SetBundleName(g_testAnotherBundleName);
1776 elementName.SetAbilityName(g_testAnotherAbilityName);
1777 avservice_->topSession_ =
1778 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
1779 bool ret = avservice_->topSession_->IsCasting();
1780 avservice_->HandleRemoveMediaCardEvent();
1781 EXPECT_EQ(ret, false);
1782 SLOGD("HandleRemoveMediaCardEvent001 end!");
1783 }
1784
1785 /**
1786 * @tc.name: HandleRemoveMediaCardEvent002
1787 * @tc.desc: Verifying the HandleRemoveMediaCardEvent method with a null session.
1788 * @tc.type: FUNC
1789 * @tc.require: #I5Y4MZ
1790 */
1791 static HWTEST_F(AVSessionServiceTest, HandleRemoveMediaCardEvent002, TestSize.Level1)
1792 {
1793 SLOGD("HandleRemoveMediaCardEvent002 begin!");
1794 avservice_->topSession_ = nullptr;
1795 avservice_->HandleRemoveMediaCardEvent();
1796 EXPECT_EQ(avservice_->topSession_, nullptr);
1797 SLOGD("HandleRemoveMediaCardEvent002 end!");
1798 }
1799
1800 /**
1801 * @tc.name: IsTopSessionPlaying001
1802 * @tc.desc: Verifying the IsTopSessionPlaying method with a null top session.
1803 * @tc.type: FUNC
1804 * @tc.require: #I5Y4MZ
1805 */
1806 static HWTEST_F(AVSessionServiceTest, IsTopSessionPlaying001, TestSize.Level1)
1807 {
1808 SLOGD("IsTopSessionPlaying001 begin!");
1809 avservice_->topSession_ = nullptr;
1810 bool ret = avservice_->IsTopSessionPlaying();
1811 EXPECT_EQ(ret, false);
1812 SLOGD("IsTopSessionPlaying001 end!");
1813 }
1814
1815 /**
1816 * @tc.name: IsTopSessionPlaying002
1817 * @tc.desc: Verifying the IsTopSessionPlaying method with a valid top session.
1818 * @tc.type: FUNC
1819 * @tc.require: #I5Y4MZ
1820 */
1821 static HWTEST_F(AVSessionServiceTest, IsTopSessionPlaying002, TestSize.Level1)
1822 {
1823 SLOGD("IsTopSessionPlaying002 begin!");
1824 std::shared_ptr<AVSessionDescriptor> histroyDescriptor = std::make_shared<AVSessionDescriptor>();
1825 avservice_->topSession_ = OHOS::sptr<AVSessionItem>::MakeSptr(*histroyDescriptor);
1826 EXPECT_NE(avservice_->topSession_, nullptr);
1827 bool ret = avservice_->IsTopSessionPlaying();
1828 EXPECT_EQ(ret, false);
1829 SLOGD("IsTopSessionPlaying002 end!");
1830 }
1831
1832 /**
1833 * @tc.name: HandleMediaCardStateChangeEvent001
1834 * @tc.desc: Verifying the HandleMediaCardStateChangeEvent method with "APPEAR" state.
1835 * @tc.type: FUNC
1836 * @tc.require: #I5Y4MZ
1837 */
1838 static HWTEST_F(AVSessionServiceTest, HandleMediaCardStateChangeEvent001, TestSize.Level1)
1839 {
1840 SLOGD("HandleMediaCardStateChangeEvent001 begin!");
1841 std::string isAppear = "APPEAR";
1842 avservice_->HandleMediaCardStateChangeEvent(isAppear);
1843 EXPECT_NE(avservice_->topSession_, nullptr);
1844 SLOGD("HandleMediaCardStateChangeEvent001 end!");
1845 }
1846
1847 /**
1848 * @tc.name: HandleMediaCardStateChangeEvent002
1849 * @tc.desc: Verifying the HandleMediaCardStateChangeEvent method with "DISAPPEAR" state.
1850 * @tc.type: FUNC
1851 * @tc.require: #I5Y4MZ
1852 */
1853 static HWTEST_F(AVSessionServiceTest, HandleMediaCardStateChangeEvent002, TestSize.Level1)
1854 {
1855 SLOGD("HandleMediaCardStateChangeEvent002 begin!");
1856 std::string isAppear = "DISAPPEAR";
1857 avservice_->HandleMediaCardStateChangeEvent(isAppear);
1858 EXPECT_NE(avservice_->topSession_, nullptr);
1859 SLOGD("HandleMediaCardStateChangeEvent002 end!");
1860 }
1861
1862 /**
1863 * @tc.name: HandleMediaCardStateChangeEvent003
1864 * @tc.desc: Verifying the HandleMediaCardStateChangeEvent method with an invalid state.
1865 * @tc.type: FUNC
1866 * @tc.require: #I5Y4MZ
1867 */
1868 static HWTEST_F(AVSessionServiceTest, HandleMediaCardStateChangeEvent003, TestSize.Level1)
1869 {
1870 SLOGD("HandleMediaCardStateChangeEvent003 begin!");
1871 std::string isAppear = "ISDISAPPEAR";
1872 avservice_->HandleMediaCardStateChangeEvent(isAppear);
1873 EXPECT_NE(avservice_->topSession_, nullptr);
1874 SLOGD("HandleMediaCardStateChangeEvent003 end!");
1875 }
1876
1877 /**
1878 * @tc.name: OnAddSystemAbility001
1879 * @tc.desc: Verifying the OnAddSystemAbility method with valid system ability ID and device ID.
1880 * @tc.type: FUNC
1881 * @tc.require: #I5Y4MZ
1882 */
1883 static HWTEST_F(AVSessionServiceTest, OnAddSystemAbility001, TestSize.Level1)
1884 {
1885 SLOGD("OnAddSystemAbility001 begin!");
1886 int32_t systemAbilityId = OHOS::XPOWER_MANAGER_SYSTEM_ABILITY_ID;
1887 const std::string deviceId = "AUDIO";
1888 avservice_->OnAddSystemAbility(systemAbilityId, deviceId);
1889 EXPECT_NE(avservice_->topSession_, nullptr);
1890 SLOGD("OnAddSystemAbility001 end!");
1891 }
1892
1893 /**
1894 * @tc.name: UpdateTopSession001
1895 * @tc.desc: Verifying the UpdateTopSession method with a valid new top session.
1896 * @tc.type: FUNC
1897 * @tc.require: #I5Y4MZ
1898 */
1899 static HWTEST_F(AVSessionServiceTest, UpdateTopSession001, TestSize.Level1)
1900 {
1901 SLOGD("UpdateTopSession001 begin!");
1902 std::shared_ptr<AVSessionDescriptor> histroyDescriptor = std::make_shared<AVSessionDescriptor>();
1903 const OHOS::sptr<AVSessionItem> newTopSession = OHOS::sptr<AVSessionItem>::MakeSptr(*histroyDescriptor);
1904 avservice_->UpdateTopSession(newTopSession);
1905 EXPECT_NE(avservice_->topSession_, nullptr);
1906 SLOGD("UpdateTopSession001 end!");
1907 }
1908
1909 /**
1910 * @tc.name: LowQualityCheck001
1911 * @tc.desc: Verifying the LowQualityCheck method with valid parameters.
1912 * @tc.type: FUNC
1913 * @tc.require: #I5Y4MZ
1914 */
1915 static HWTEST_F(AVSessionServiceTest, LowQualityCheck001, TestSize.Level1)
1916 {
1917 SLOGD("LowQualityCheck001 begin!");
1918 int32_t uid = g_playOnCall;
1919 int32_t pid = g_pauseOnCall;
1920 StreamUsage streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
1921 RendererState rendererState = RendererState::RENDERER_PAUSED;
1922 avservice_->LowQualityCheck(uid, pid, streamUsage, rendererState);
1923 EXPECT_NE(avservice_->topSession_, nullptr);
1924 SLOGD("LowQualityCheck001 end!");
1925 }
1926
1927 /**
1928 * @tc.name: PlayStateCheck001
1929 * @tc.desc: Verifying the PlayStateCheck method with valid parameters.
1930 * @tc.type: FUNC
1931 * @tc.require: #I5Y4MZ
1932 */
1933 static HWTEST_F(AVSessionServiceTest, PlayStateCheck001, TestSize.Level1)
1934 {
1935 SLOGD("PlayStateCheck001 begin!");
1936 int32_t uid = AVSESSION_ERROR_BASE;
1937 StreamUsage streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
1938 RendererState rendererState = RendererState::RENDERER_PAUSED;
1939 avservice_->PlayStateCheck(uid, streamUsage, rendererState);
1940 EXPECT_NE(avservice_->topSession_, nullptr);
1941 SLOGD("PlayStateCheck001 end!");
1942 }
1943
1944 /**
1945 * @tc.name: NotifyBackgroundReportCheck001
1946 * @tc.desc: Verifying NotifyBackgroundReportCheck with RENDERER_RUNNING state.
1947 * @tc.type: FUNC
1948 * @tc.require: #I5Y4MZ
1949 */
1950 static HWTEST_F(AVSessionServiceTest, NotifyBackgroundReportCheck001, TestSize.Level1)
1951 {
1952 SLOGD("NotifyBackgroundReportCheck001 begin!");
1953 int32_t uid = g_playOnCall;
1954 int32_t pid = g_pauseOnCall;
1955 StreamUsage streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
1956 RendererState rendererState = RendererState::RENDERER_RUNNING;
1957 avservice_->NotifyBackgroundReportCheck(uid, pid, streamUsage, rendererState);
1958 EXPECT_NE(avservice_->topSession_, nullptr);
1959 SLOGD("NotifyBackgroundReportCheck001 end!");
1960 }
1961
1962 /**
1963 * @tc.name: NotifyBackgroundReportCheck002
1964 * @tc.desc: Verifying NotifyBackgroundReportCheck with RENDERER_PAUSED state.
1965 * @tc.type: FUNC
1966 * @tc.require: #I5Y4MZ
1967 */
1968 static HWTEST_F(AVSessionServiceTest, NotifyBackgroundReportCheck002, TestSize.Level1)
1969 {
1970 SLOGD("NotifyBackgroundReportCheck002 begin!");
1971 int32_t uid = g_playOnCall;
1972 int32_t pid = g_pauseOnCall;
1973 StreamUsage streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
1974 RendererState rendererState = RendererState::RENDERER_PAUSED;
1975 avservice_->NotifyBackgroundReportCheck(uid, pid, streamUsage, rendererState);
1976 EXPECT_NE(avservice_->topSession_, nullptr);
1977 SLOGD("NotifyBackgroundReportCheck002 end!");
1978 }
1979
1980 /**
1981 * @tc.name: ServiceCallback001
1982 * @tc.desc: Verifying ServiceCallback with a null session item.
1983 * @tc.type: FUNC
1984 * @tc.require: #I5Y4MZ
1985 */
1986 static HWTEST_F(AVSessionServiceTest, ServiceCallback001, TestSize.Level1)
1987 {
1988 SLOGD("ServiceCallback001 begin!");
1989 OHOS::AppExecFwk::ElementName elementName;
1990 elementName.SetBundleName(g_testAnotherBundleName);
1991 elementName.SetAbilityName(g_testAnotherAbilityName);
1992 auto sessionItem =
1993 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
1994 EXPECT_EQ(sessionItem, nullptr);
1995 avservice_->ServiceCallback(sessionItem);
1996 SLOGD("ServiceCallback001 end!");
1997 }
1998
1999 /**
2000 * @tc.name: IsParamInvalid001
2001 * @tc.desc: Verifying IsParamInvalid with an empty tag.
2002 * @tc.type: FUNC
2003 * @tc.require: #I5Y4MZ
2004 */
2005 static HWTEST_F(AVSessionServiceTest, IsParamInvalid001, TestSize.Level1)
2006 {
2007 SLOGD("IsParamInvalid001 begin!");
2008 std::string tag = "";
2009 int32_t type = AVSession::SESSION_TYPE_AUDIO;
2010 OHOS::AppExecFwk::ElementName elementName;
2011 elementName.SetBundleName(g_testAnotherBundleName);
2012 elementName.SetAbilityName(g_testAnotherAbilityName);
2013 bool result = avservice_->IsParamInvalid(tag, type, elementName);
2014 EXPECT_FALSE(result);
2015 SLOGD("IsParamInvalid001 end!");
2016 }
2017
2018 /**
2019 * @tc.name: IsParamInvalid002
2020 * @tc.desc: Verifying IsParamInvalid with an invalid session type.
2021 * @tc.type: FUNC
2022 * @tc.require: #I5Y4MZ
2023 */
2024 static HWTEST_F(AVSessionServiceTest, IsParamInvalid002, TestSize.Level1)
2025 {
2026 SLOGD("IsParamInvalid002 begin!");
2027 std::string tag = "testTag";
2028 int32_t type = AVSession::SESSION_TYPE_INVALID;
2029 OHOS::AppExecFwk::ElementName elementName;
2030 elementName.SetBundleName("com.example.bundle");
2031 elementName.SetAbilityName("com.example.ability");
2032 bool result = avservice_->IsParamInvalid(tag, type, elementName);
2033 EXPECT_FALSE(result);
2034 SLOGD("IsParamInvalid002 end!");
2035 }
2036
2037 /**
2038 * @tc.name: IsParamInvalid003
2039 * @tc.desc: Verifying IsParamInvalid with an empty bundle name.
2040 * @tc.type: FUNC
2041 * @tc.require: #I5Y4MZ
2042 */
2043 static HWTEST_F(AVSessionServiceTest, IsParamInvalid003, TestSize.Level1)
2044 {
2045 SLOGD("IsParamInvalid003 begin!");
2046 std::string tag = "testTag";
2047 int32_t type = AVSession::SESSION_TYPE_AUDIO;
2048 OHOS::AppExecFwk::ElementName elementName;
2049 elementName.SetBundleName("");
2050 elementName.SetAbilityName(g_testAnotherAbilityName);
2051 bool result = avservice_->IsParamInvalid(tag, type, elementName);
2052 EXPECT_FALSE(result);
2053 SLOGD("IsParamInvalid003 end!");
2054 }
2055
2056 /**
2057 * @tc.name: IsParamInvalid004
2058 * @tc.desc: Verifying IsParamInvalid with an empty ability name.
2059 * @tc.type: FUNC
2060 * @tc.require: #I5Y4MZ
2061 */
2062 static HWTEST_F(AVSessionServiceTest, IsParamInvalid004, TestSize.Level1)
2063 {
2064 SLOGD("IsParamInvalid004 begin!");
2065 std::string tag = "testTag";
2066 int32_t type = AVSession::SESSION_TYPE_AUDIO;
2067 OHOS::AppExecFwk::ElementName elementName;
2068 elementName.SetBundleName(g_testAnotherBundleName);
2069 elementName.SetAbilityName("");
2070 bool result = avservice_->IsParamInvalid(tag, type, elementName);
2071 EXPECT_FALSE(result);
2072 SLOGD("IsParamInvalid004 end!");
2073 }
2074
2075 /**
2076 * @tc.name: IsLocalDevice001
2077 * @tc.desc: Verifying IsLocalDevice with a valid local network ID.
2078 * @tc.type: FUNC
2079 * @tc.require: #I5Y4MZ
2080 */
2081 static HWTEST_F(AVSessionServiceTest, IsLocalDevice001, TestSize.Level1)
2082 {
2083 SLOGD("IsLocalDevice001 begin!");
2084 const std::string networkId = "LocalDevice";
2085 bool result = avservice_->IsLocalDevice(networkId);
2086 EXPECT_TRUE(result);
2087 SLOGD("IsLocalDevice001 end!");
2088 }
2089
2090 /**
2091 * @tc.name: GetDeviceInfo002
2092 * @tc.desc: Verifying GetDeviceInfo with a valid session item and descriptors.
2093 * @tc.type: FUNC
2094 * @tc.require: #I5Y4MZ
2095 */
2096 static HWTEST_F(AVSessionServiceTest, GetDeviceInfo002, TestSize.Level1)
2097 {
2098 SLOGI("GetDeviceInfo002 begin!");
2099 std::shared_ptr<AVSessionDescriptor> histroyDescriptor = std::make_shared<AVSessionDescriptor>();
2100 auto avsessionHere = OHOS::sptr<AVSessionItem>::MakeSptr(*histroyDescriptor);
2101 std::vector<OHOS::AudioStandard::AudioDeviceDescriptor> descriptors = {
2102 OHOS::AudioStandard::AudioDeviceDescriptor(OHOS::AudioStandard::DeviceType::DEVICE_TYPE_EARPIECE,
2103 OHOS::AudioStandard::DeviceRole::INPUT_DEVICE, 1, 1, "LocalDevice")
2104 };
2105 avservice_->SetDeviceInfo(descriptors, avsessionHere);
2106 avservice_->GetDeviceInfo(avsessionHere, descriptors, descriptors, descriptors);
2107 EXPECT_NE(avsessionHere, nullptr);
2108 SLOGI("GetDeviceInfo002 end!");
2109 }
2110
2111 /**
2112 * @tc.name: CastAudioProcess001
2113 * @tc.desc: Verifying CastAudioProcess with a valid session item and descriptors.
2114 * @tc.type: FUNC
2115 * @tc.require: #I5Y4MZ
2116 */
2117 static HWTEST_F(AVSessionServiceTest, CastAudioProcess001, TestSize.Level1)
2118 {
2119 SLOGI("CastAudioProcess001 begin!");
2120 EXPECT_TRUE(avservice_ != nullptr);
2121 OHOS::AppExecFwk::ElementName elementName;
2122 elementName.SetBundleName(g_testAnotherBundleName);
2123 elementName.SetAbilityName(g_testAnotherAbilityName);
2124 OHOS::sptr<AVSessionItem> avsessionHere =
2125 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_VOICE_CALL, false, elementName);
2126 std::vector<OHOS::AudioStandard::AudioDeviceDescriptor> descriptors;
2127 avservice_->GetDeviceInfo(avsessionHere, descriptors, descriptors, descriptors);
2128 const std::string sourceSessionInfo = "123443";
2129 auto ret = avservice_->CastAudioProcess(descriptors, sourceSessionInfo, avsessionHere);
2130 EXPECT_EQ(ret, AVSESSION_SUCCESS);
2131 SLOGI("CastAudioProcess001 end!");
2132 }
2133
2134 /**
2135 * @tc.name: CastAudioProcess002
2136 * @tc.desc: Verifying CastAudioProcess with a valid session item and descriptors.
2137 * @tc.type: FUNC
2138 * @tc.require: #I5Y4MZ
2139 */
2140 static HWTEST_F(AVSessionServiceTest, CastAudioProcess002, TestSize.Level1)
2141 {
2142 SLOGI("CastAudioProcess002 begin!");
2143 std::shared_ptr<AVSessionDescriptor> histroyDescriptor = std::make_shared<AVSessionDescriptor>();
2144 auto avsessionHere = OHOS::sptr<AVSessionItem>::MakeSptr(*histroyDescriptor);
2145 std::vector<OHOS::AudioStandard::AudioDeviceDescriptor> descriptors = {
2146 OHOS::AudioStandard::AudioDeviceDescriptor(OHOS::AudioStandard::DeviceType::DEVICE_TYPE_EARPIECE,
2147 OHOS::AudioStandard::DeviceRole::INPUT_DEVICE, 1, 1, "LocalDevice")
2148 };
2149 avservice_->SetDeviceInfo(descriptors, avsessionHere);
2150 avservice_->GetDeviceInfo(avsessionHere, descriptors, descriptors, descriptors);
2151 EXPECT_NE(avsessionHere, nullptr);
2152 const std::string sourceSessionInfo = "123443";
2153 auto ret = avservice_->CastAudioProcess(descriptors, sourceSessionInfo, avsessionHere);
2154 EXPECT_EQ(ret, AVSESSION_SUCCESS);
2155 SLOGI("CastAudioProcess002 end!");
2156 }
2157
2158 /**
2159 * @tc.name: CastAudioInner001
2160 * @tc.desc: Verifying CastAudioInner with a valid session item and descriptors.
2161 * @tc.type: FUNC
2162 * @tc.require: #I5Y4MZ
2163 */
2164 static HWTEST_F(AVSessionServiceTest, CastAudioInner001, TestSize.Level1)
2165 {
2166 SLOGI("CastAudioInner001 begin!");
2167 EXPECT_TRUE(avservice_ != nullptr);
2168 std::shared_ptr<AVSessionDescriptor> histroyDescriptor = std::make_shared<AVSessionDescriptor>();
2169 auto avsessionHere = OHOS::sptr<AVSessionItem>::MakeSptr(*histroyDescriptor);
2170 std::vector<OHOS::AudioStandard::AudioDeviceDescriptor> descriptors = {
2171 OHOS::AudioStandard::AudioDeviceDescriptor(OHOS::AudioStandard::DeviceType::DEVICE_TYPE_EARPIECE,
2172 OHOS::AudioStandard::DeviceRole::INPUT_DEVICE, 1, 1, "LocalDevice")
2173 };
2174 const std::string sourceSessionInfo = "123443";
2175 auto ret = avservice_->CastAudioInner(descriptors, sourceSessionInfo, avsessionHere);
2176 EXPECT_EQ(ret, AVSESSION_ERROR);
2177 SLOGI("CastAudioInner001 end!");
2178 }
2179
2180 /**
2181 * @tc.name: CancelCastAudioInner001
2182 * @tc.desc: Verifying CancelCastAudioInner with a valid session item and descriptors.
2183 * @tc.type: FUNC
2184 * @tc.require: #I5Y4MZ
2185 */
2186 static HWTEST_F(AVSessionServiceTest, CancelCastAudioInner001, TestSize.Level1)
2187 {
2188 SLOGI("CancelCastAudioInner001 begin!");
2189 EXPECT_TRUE(avservice_ != nullptr);
2190 OHOS::AppExecFwk::ElementName elementName;
2191 elementName.SetBundleName(g_testAnotherBundleName);
2192 elementName.SetAbilityName(g_testAnotherAbilityName);
2193 OHOS::sptr<AVSessionItem> avsessionHere =
2194 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_VOICE_CALL, false, elementName);
2195 std::vector<OHOS::AudioStandard::AudioDeviceDescriptor> descriptors = {
2196 OHOS::AudioStandard::AudioDeviceDescriptor(OHOS::AudioStandard::DeviceType::DEVICE_TYPE_EARPIECE,
2197 OHOS::AudioStandard::DeviceRole::INPUT_DEVICE, 1, 1, "LocalDevice")
2198 };
2199 const std::string sourceSessionInfo = "123443";
2200 auto ret = avservice_->CancelCastAudioInner(descriptors, sourceSessionInfo, avsessionHere);
2201 EXPECT_EQ(ret, AVSESSION_SUCCESS);
2202 SLOGI("CancelCastAudioInner001 end!");
2203 }
2204
2205 /**
2206 * @tc.name: CastAudioForAll001
2207 * @tc.desc: Verifying CastAudioForAll with valid descriptors.
2208 * @tc.type: FUNC
2209 * @tc.require: #I5Y4MZ
2210 */
2211 static HWTEST_F(AVSessionServiceTest, CastAudioForAll001, TestSize.Level1)
2212 {
2213 SLOGI("CastAudioForAll001 begin!");
2214 EXPECT_TRUE(avservice_ != nullptr);
2215 std::vector<OHOS::AudioStandard::AudioDeviceDescriptor> descriptors = {
2216 OHOS::AudioStandard::AudioDeviceDescriptor(OHOS::AudioStandard::DeviceType::DEVICE_TYPE_EARPIECE,
2217 OHOS::AudioStandard::DeviceRole::INPUT_DEVICE, 1, 1, "LocalDevice")
2218 };
2219 auto ret = avservice_->CastAudioForAll(descriptors);
2220 EXPECT_EQ(ret, AVSESSION_ERROR);
2221 SLOGI("CastAudioForAll001 end!");
2222 }
2223
2224 /**
2225 * @tc.name: ClearControllerForClientDiedNoLock002
2226 * @tc.desc: Verifying ClearControllerForClientDiedNoLock with a valid PID.
2227 * @tc.type: FUNC
2228 * @tc.require: #I5Y4MZ
2229 */
2230 static HWTEST_F(AVSessionServiceTest, ClearControllerForClientDiedNoLock002, TestSize.Level1)
2231 {
2232 SLOGI("ClearControllerForClientDiedNoLock002 begin!");
2233 EXPECT_TRUE(avservice_ != nullptr);
2234 pid_t pid = 1234;
2235 avservice_->ClearControllerForClientDiedNoLock(pid);
2236 EXPECT_TRUE(avservice_ != nullptr);
2237 SLOGI("ClearControllerForClientDiedNoLock002 end!");
2238 }
2239
2240 /**
2241 * @tc.name: CheckAndCreateDir001
2242 * @tc.desc: Verifying CheckAndCreateDir with a valid file path.
2243 * @tc.type: FUNC
2244 * @tc.require: #I5Y4MZ
2245 */
2246 static HWTEST_F(AVSessionServiceTest, CheckAndCreateDir001, TestSize.Level1)
2247 {
2248 SLOGI("CheckAndCreateDir001 begin!");
2249 EXPECT_TRUE(avservice_ != nullptr);
2250 const string filePath = "/data/path";
2251 bool ret = avservice_->CheckAndCreateDir(filePath);
2252 EXPECT_TRUE(ret);
2253 SLOGI("CheckAndCreateDir001 end!");
2254 }
2255
2256 /**
2257 * @tc.name: SaveStringToFileEx001
2258 * @tc.desc: Verifying SaveStringToFileEx with a valid file path and content.
2259 * @tc.type: FUNC
2260 * @tc.require: #I5Y4MZ
2261 */
2262 static HWTEST_F(AVSessionServiceTest, SaveStringToFileEx001, TestSize.Level1)
2263 {
2264 SLOGI("SaveStringToFileEx001 begin!");
2265 std::string filePath = "uripath";
2266 std::string content = "123456";
2267 bool ret = avservice_->SaveStringToFileEx(filePath, content);
2268 EXPECT_EQ(ret, true);
2269 SLOGI("SaveStringToFileEx001 end!");
2270 }
2271
2272 /**
2273 * @tc.name: SaveStringToFileEx002
2274 * @tc.desc: Verifying SaveStringToFileEx with an empty content.
2275 * @tc.type: FUNC
2276 * @tc.require: #I5Y4MZ
2277 */
2278 static HWTEST_F(AVSessionServiceTest, SaveStringToFileEx002, TestSize.Level1)
2279 {
2280 SLOGI("SaveStringToFileEx002 begin!");
2281 OHOS::AppExecFwk::ElementName elementName;
2282 elementName.SetBundleName(g_testAnotherBundleName);
2283 elementName.SetAbilityName(g_testAnotherAbilityName);
2284 OHOS::sptr<AVSessionItem> avsessionItem =
2285 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
2286
2287 std::string filePath = avservice_->GetAVSortDir();
2288 std::string content = "";
2289 bool ret = avservice_->SaveStringToFileEx(filePath, content);
2290 EXPECT_EQ(ret, false);
2291 SLOGI("SaveStringToFileEx002 end!");
2292 }
2293
2294 /**
2295 * @tc.name: RemoveExpired001
2296 * @tc.desc: Verifying RemoveExpired with an expired time point.
2297 * @tc.type: FUNC
2298 * @tc.require: #I5Y4MZ
2299 */
2300 static HWTEST_F(AVSessionServiceTest, RemoveExpired001, TestSize.Level1)
2301 {
2302 SLOGD("RemoveExpired001 begin!");
2303 std::list<std::chrono::system_clock::time_point> timeList;
2304 auto now = std::chrono::system_clock::now();
2305 int32_t timeThreshold = 5;
2306 timeList.push_back(now - std::chrono::seconds(10));
2307 avservice_->RemoveExpired(timeList, now, timeThreshold);
2308
2309 EXPECT_TRUE(timeList.empty());
2310 SLOGD("RemoveExpired001 end!");
2311 }
2312
2313 /**
2314 * @tc.name: RemoveExpired002
2315 * @tc.desc: Verifying RemoveExpired with a non-expired time point.
2316 * @tc.type: FUNC
2317 * @tc.require: #I5Y4MZ
2318 */
2319 static HWTEST_F(AVSessionServiceTest, RemoveExpired002, TestSize.Level1)
2320 {
2321 SLOGD("RemoveExpired002 begin!");
2322 std::list<std::chrono::system_clock::time_point> timeList;
2323 auto now = std::chrono::system_clock::now();
2324 int32_t timeThreshold = 5;
2325 timeList.push_back(now - std::chrono::seconds(3));
2326
2327 avservice_->RemoveExpired(timeList, now, timeThreshold);
2328 EXPECT_EQ(timeList.size(), 1);
2329 SLOGD("RemoveExpired002 end!");
2330 }
2331
2332 /**
2333 * @tc.name: RemoveExpired003
2334 * @tc.desc: Verifying RemoveExpired with an empty time list.
2335 * @tc.type: FUNC
2336 * @tc.require: #I5Y4MZ
2337 */
2338 static HWTEST_F(AVSessionServiceTest, RemoveExpired003, TestSize.Level1)
2339 {
2340 SLOGD("RemoveExpired003 begin!");
2341 std::list<std::chrono::system_clock::time_point> timeList;
2342 auto now = std::chrono::system_clock::now();
2343 int32_t timeThreshold = 5;
2344 avservice_->RemoveExpired(timeList, now, timeThreshold);
2345 EXPECT_TRUE(timeList.empty());
2346 SLOGD("RemoveExpired003 end!");
2347 }
2348
2349 /**
2350 * @tc.name: NotifyFlowControl001
2351 * @tc.desc: Verifying NotifyFlowControl with a full flow control list.
2352 * @tc.type: FUNC
2353 * @tc.require: #I5Y4MZ
2354 */
2355 static HWTEST_F(AVSessionServiceTest, NotifyFlowControl001, TestSize.Level1)
2356 {
2357 SLOGD("NotifyFlowControl001 begin!");
2358 avservice_->flowControlPublishTimestampList_.clear();
2359 const size_t count = 3;
2360 for (size_t i = 0; i < count; ++i) {
2361 avservice_->flowControlPublishTimestampList_.push_back(std::chrono::system_clock::now());
2362 }
2363 bool result = avservice_->NotifyFlowControl();
2364 EXPECT_TRUE(result);
2365 EXPECT_EQ(avservice_->flowControlPublishTimestampList_.size(), count);
2366 SLOGD("NotifyFlowControl001 end!");
2367 }
2368
2369 /**
2370 * @tc.name: NotifyFlowControl002
2371 * @tc.desc: Verifying NotifyFlowControl with a non-full flow control list.
2372 * @tc.type: FUNC
2373 * @tc.require: #I5Y4MZ
2374 */
2375 static HWTEST_F(AVSessionServiceTest, NotifyFlowControl002, TestSize.Level1)
2376 {
2377 SLOGD("NotifyFlowControl002 begin!");
2378 const size_t count = 3;
2379 avservice_->flowControlPublishTimestampList_.clear();
2380 for (size_t i = 0; i < count - 1; ++i) {
2381 avservice_->flowControlPublishTimestampList_.push_back(std::chrono::system_clock::now());
2382 }
2383 bool result = avservice_->NotifyFlowControl();
2384 EXPECT_FALSE(result);
2385 SLOGD("NotifyFlowControl002 end!");
2386 }
2387
2388 /**
2389 * @tc.name: NotifyRemoteDistributedSessionControllersChanged001
2390 * @tc.desc: Verifying NotifyRemoteDistributedSessionControllersChanged with a valid session controller.
2391 * @tc.type: FUNC
2392 * @tc.require: #I5Y4MZ
2393 */
2394 static HWTEST_F(AVSessionServiceTest, NotifyRemoteDistributedSessionControllersChanged001, TestSize.Level1)
2395 {
2396 SLOGD("NotifyRemoteDistributedSessionControllersChanged001 begin!");
2397 std::vector<OHOS::sptr<IRemoteObject>> sessionControllers;
2398 avservice_->NotifyRemoteDistributedSessionControllersChanged(sessionControllers);
2399 OHOS::sptr<OHOS::ISystemAbilityManager> mgr =
2400 OHOS::SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
2401 EXPECT_TRUE(mgr != nullptr);
2402 OHOS::sptr<IRemoteObject> obj = mgr->GetSystemAbility(OHOS::AVSESSION_SERVICE_ID);
2403 sessionControllers.push_back(obj);
2404 avservice_->NotifyRemoteDistributedSessionControllersChanged(sessionControllers);
2405 EXPECT_TRUE(avservice_ != nullptr);
2406 SLOGD("NotifyRemoteDistributedSessionControllersChanged001 end!");
2407 }
2408
2409 /**
2410 * @tc.name: SuperLauncher001
2411 * @tc.desc: Verifying SuperLauncher with init state
2412 * @tc.type: FUNC
2413 * @tc.require: #I5Y4MZ
2414 */
2415 static HWTEST_F(AVSessionServiceTest, SuperLauncher001, TestSize.Level1)
2416 {
2417 SLOGD("SuperLauncher001 begin!");
2418 avservice_->SuperLauncher("adcdef", "SuperLauncher-Dual", "", "CONNECT_SUCC");
2419 EXPECT_EQ(avservice_->migrateAVSession_->supportCrossMediaPlay_, false);
2420 SLOGD("SuperLauncher001 end!");
2421 }
2422
2423 /**
2424 * @tc.name: ReleaseSuperLauncher001
2425 * @tc.desc: Verifying ReleaseSuperLauncher with SupportCrossMediaPlay state
2426 * @tc.type: FUNC
2427 * @tc.require: #I5Y4MZ
2428 */
2429 static HWTEST_F(AVSessionServiceTest, ReleaseSuperLauncher001, TestSize.Level1)
2430 {
2431 SLOGD("ReleaseSuperLauncher001 begin!");
2432 avservice_->ReleaseSuperLauncher("SuperLauncher-Dual");
2433 EXPECT_EQ(avservice_->migrateAVSession_->supportCrossMediaPlay_, false);
2434 SLOGD("ReleaseSuperLauncher001 end!");
2435 }
2436
2437 /**
2438 * @tc.name: ConnectSuperLauncher001
2439 * @tc.desc: Verifying ConnectSuperLauncher001 with init state
2440 * @tc.type: FUNC
2441 * @tc.require: #I5Y4MZ
2442 */
2443 static HWTEST_F(AVSessionServiceTest, ConnectSuperLauncher001, TestSize.Level1)
2444 {
2445 SLOGD("ConnectSuperLauncher001 begin!");
2446 avservice_->ConnectSuperLauncher("adcdef", "SuperLauncher-Dual");
2447 EXPECT_NE(avservice_->migrateAVSession_->servicePtr_, nullptr);
2448 SLOGD("ConnectSuperLauncher001 end!");
2449 }
2450
2451 /**
2452 * @tc.name: SucceedSuperLauncher001
2453 * @tc.desc: Verifying SucceedSuperLauncher001 with init state
2454 * @tc.type: FUNC
2455 * @tc.require: #I5Y4MZ
2456 */
2457 static HWTEST_F(AVSessionServiceTest, SucceedSuperLauncher001, TestSize.Level1)
2458 {
2459 SLOGD("SucceedSuperLauncher001 begin!");
2460 avservice_->SucceedSuperLauncher("adcdef", "SuperLauncher-Dual");
2461 EXPECT_EQ(avservice_->migrateAVSession_->supportCrossMediaPlay_, false);
2462 SLOGD("SucceedSuperLauncher001 end!");
2463 }