1 /*
2 * Copyright (c) 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 <chrono>
18 #include <thread>
19
20 #include "accesstoken_kit.h"
21 #include "nativetoken_kit.h"
22 #include "token_setproc.h"
23 #include "avmeta_data.h"
24 #include "avplayback_state.h"
25 #include "avsession_errors.h"
26 #include "avsession_item.h"
27 #include "avsession_log.h"
28 #include "migrate_avsession_constant.h"
29 #include "system_ability_definition.h"
30 #include "avsession_service.h"
31
32 using namespace testing::ext;
33 using namespace OHOS::AVSession;
34
35 static char g_testSessionTag[] = "test";
36 static char g_testAnotherBundleName[] = "testAnother.ohos.avsession";
37 static char g_testAnotherAbilityName[] = "testAnother.ability";
38 static std::shared_ptr<MigrateAVSessionServer> g_MigrateAVSessionServer {nullptr};
39 static std::shared_ptr<AVSessionService> g_AVSessionService {nullptr};
40 static OHOS::sptr<AVSessionItem> g_AVSessionItem {nullptr};
41 static OHOS::sptr<AVControllerItem> g_AVControllerItem {nullptr};
42
43 class AVsessionItemTest : public testing::Test {
44 public:
45
46 static void SetUpTestCase();
47 static void TearDownTestCase();
48 void SetUp();
49 void TearDown();
50 };
51
52 class AVSessionCallbackImpl : public AVSessionCallback {
53 public:
54 void OnPlay() override;
55 void OnPause() override;
OnStop()56 void OnStop() override {};
57 void OnPlayNext() override;
58 void OnPlayPrevious() override;
OnFastForward(int64_t time)59 void OnFastForward(int64_t time) override {};
OnRewind(int64_t time)60 void OnRewind(int64_t time) override {};
OnSeek(int64_t time)61 void OnSeek(int64_t time) override {};
OnSetSpeed(double speed)62 void OnSetSpeed(double speed) override {};
OnSetLoopMode(int32_t loopMode)63 void OnSetLoopMode(int32_t loopMode) override {};
OnSetTargetLoopMode(int32_t targetLoopMode)64 void OnSetTargetLoopMode(int32_t targetLoopMode) override {};
OnToggleFavorite(const std::string & mediaId)65 void OnToggleFavorite(const std::string& mediaId) override {};
OnMediaKeyEvent(const OHOS::MMI::KeyEvent & keyEvent)66 void OnMediaKeyEvent(const OHOS::MMI::KeyEvent& keyEvent) override {};
OnOutputDeviceChange(const int32_t connectionState,const OHOS::AVSession::OutputDeviceInfo & outputDeviceInfo)67 void OnOutputDeviceChange(const int32_t connectionState,
68 const OHOS::AVSession::OutputDeviceInfo& outputDeviceInfo) override {};
OnCommonCommand(const std::string & commonCommand,const OHOS::AAFwk::WantParams & commandArgs)69 void OnCommonCommand(const std::string& commonCommand, const OHOS::AAFwk::WantParams& commandArgs) override {};
OnSkipToQueueItem(int32_t itemId)70 void OnSkipToQueueItem(int32_t itemId) override {};
OnAVCallAnswer()71 void OnAVCallAnswer() override {};
OnAVCallHangUp()72 void OnAVCallHangUp() override {};
OnAVCallToggleCallMute()73 void OnAVCallToggleCallMute() override {};
OnPlayFromAssetId(int64_t assetId)74 void OnPlayFromAssetId(int64_t assetId) override {};
OnCastDisplayChange(const CastDisplayInfo & castDisplayInfo)75 void OnCastDisplayChange(const CastDisplayInfo& castDisplayInfo) override {};
76
77 ~AVSessionCallbackImpl() override;
78 };
79
80 class MockIAVCastControllerProxy : public OHOS::AVSession::IAVCastControllerProxy {
Release()81 void Release() override {}
RegisterControllerListener(const std::shared_ptr<IAVCastControllerProxyListener> listener)82 int32_t RegisterControllerListener(const
83 std::shared_ptr<IAVCastControllerProxyListener> listener) override { return 0; }
UnRegisterControllerListener(const std::shared_ptr<IAVCastControllerProxyListener> listener)84 int32_t UnRegisterControllerListener(const
85 std::shared_ptr<IAVCastControllerProxyListener> listener) override { return 0; }
GetCurrentItem()86 AVQueueItem GetCurrentItem() override { return AVQueueItem(); }
Start(const AVQueueItem & item)87 int32_t Start(const AVQueueItem& item) override { return 0; }
Prepare(const AVQueueItem & item)88 int32_t Prepare(const AVQueueItem& item) override { return 0; }
SendControlCommand(const AVCastControlCommand cmd)89 void SendControlCommand(const AVCastControlCommand cmd) override {}
GetDuration(int32_t & duration)90 int32_t GetDuration(int32_t& duration) override { return 0; }
GetCastAVPlaybackState(AVPlaybackState & state)91 int32_t GetCastAVPlaybackState(AVPlaybackState& state) override { return 0; }
SetValidAbility(const std::vector<int32_t> & validAbilityList)92 int32_t SetValidAbility(const std::vector<int32_t>& validAbilityList) override { return 0; }
GetValidAbility(std::vector<int32_t> & validAbilityList)93 int32_t GetValidAbility(std::vector<int32_t>& validAbilityList) override { return 0; }
SetDisplaySurface(std::string & surfaceId)94 int32_t SetDisplaySurface(std::string& surfaceId) override { return 0; }
ProcessMediaKeyResponse(const std::string & assetId,const std::vector<uint8_t> & response)95 int32_t ProcessMediaKeyResponse(const
96 std::string& assetId, const std::vector<uint8_t>& response) override { return 0; }
GetSupportedDecoders(std::vector<std::string> & decoderTypes)97 int32_t GetSupportedDecoders(std::vector<std::string>& decoderTypes) override { return 0; }
GetRecommendedResolutionLevel(std::string & decoderType,ResolutionLevel & resolutionLevel)98 int32_t GetRecommendedResolutionLevel(std::string& decoderType, ResolutionLevel& resolutionLevel)
99 override { return 0; }
GetSupportedHdrCapabilities(std::vector<HDRFormat> & hdrFormats)100 int32_t GetSupportedHdrCapabilities(std::vector<HDRFormat>& hdrFormats) override { return 0; }
GetSupportedPlaySpeeds(std::vector<float> & playSpeeds)101 int32_t GetSupportedPlaySpeeds(std::vector<float>& playSpeeds) override { return 0; }
RefreshCurrentAVQueueItem(const AVQueueItem & avQueueItem)102 int32_t RefreshCurrentAVQueueItem(const AVQueueItem& avQueueItem) override { return 0; }
103 };
104
SetUpTestCase()105 void AVsessionItemTest::SetUpTestCase()
106 {
107 SLOGI("AVsessionItemTest SetUpTestCase");
108 g_MigrateAVSessionServer = std::make_shared<MigrateAVSessionServer>();
109 OHOS::AppExecFwk::ElementName elementName;
110 elementName.SetBundleName(g_testAnotherBundleName);
111 elementName.SetAbilityName(g_testAnotherAbilityName);
112 g_AVSessionService = std::make_shared<AVSessionService>(OHOS::AVSESSION_SERVICE_ID, true);
113 g_AVSessionItem = g_AVSessionService->CreateSessionInner(g_testSessionTag,
114 AVSession::SESSION_TYPE_VOICE_CALL, false, elementName);
115 g_AVControllerItem = g_AVSessionService->CreateNewControllerForSession(
116 g_AVSessionItem->GetPid(), g_AVSessionItem);
117 }
118
TearDownTestCase()119 void AVsessionItemTest::TearDownTestCase()
120 {
121 SLOGI("AVsessionItemTest TearDownTestCase");
122 g_AVSessionService->HandleSessionRelease(g_AVSessionItem->GetSessionId());
123 g_AVControllerItem->Destroy();
124 g_AVSessionItem->Destroy();
125 }
126
SetUp()127 void AVsessionItemTest::SetUp()
128 {}
129
TearDown()130 void AVsessionItemTest::TearDown()
131 {}
132
133 /**
134 * @tc.name: AVSessionItem_DestroyTask_001
135 * @tc.desc: Test DestroyTask when the session is already destroyed.
136 * @tc.type: FUNC
137 * @tc.require: #I5Y4MZ
138 */
139 HWTEST_F(AVsessionItemTest, AVSessionItem_DestroyTask_001, TestSize.Level1)
140 {
141 SLOGD("AVSessionItem_DestroyTask_001 begin!");
142 g_AVSessionItem->isDestroyed_ = true;
143 int32_t result = g_AVSessionItem->DestroyTask(false);
144 EXPECT_EQ(result, AVSESSION_SUCCESS);
145 SLOGD("AVSessionItem_DestroyTask_001 end!");
146 }
147
148 /**
149 * @tc.name: AVSessionItem_DestroyTask_002
150 * @tc.desc: Test DestroyTask with no valid controllers in the controllers list.
151 * @tc.type: FUNC
152 * @tc.require: #I5Y4MZ
153 */
154 HWTEST_F(AVsessionItemTest, AVSessionItem_DestroyTask_002, TestSize.Level1)
155 {
156 SLOGD("AVSessionItem_DestroyTask_002 begin!");
157 g_AVSessionItem->controllers_.clear();
158 int32_t result = g_AVSessionItem->DestroyTask(false);
159 EXPECT_EQ(result, AVSESSION_SUCCESS);
160 SLOGD("AVSessionItem_DestroyTask_002 end!");
161 }
162
163 /**
164 * @tc.name: AVSessionItem_DestroyTask_003
165 * @tc.desc: Test DestroyTask with castHandle_ > 0 but sessionTag_ is "RemoteCast".
166 * @tc.type: FUNC
167 * @tc.require: #I5Y4MZ
168 */
169 HWTEST_F(AVsessionItemTest, AVSessionItem_DestroyTask_003, TestSize.Level1)
170 {
171 SLOGD("AVSessionItem_DestroyTask_003 begin!");
172 g_AVSessionItem->descriptor_.sessionTag_ = "RemoteCast";
173 g_AVSessionItem->castHandle_ = 1;
174 int32_t result = g_AVSessionItem->DestroyTask(false);
175 EXPECT_EQ(result, AVSESSION_SUCCESS);
176 SLOGD("AVSessionItem_DestroyTask_003 end!");
177 }
178
179 /**
180 * @tc.name: AVSessionItem_DestroyTask_004
181 * @tc.desc: Test DestroyTask with castHandle_ > 0 and sessionTag_ is not "RemoteCast".
182 * @tc.type: FUNC
183 * @tc.require: #I5Y4MZ
184 */
185 HWTEST_F(AVsessionItemTest, AVSessionItem_DestroyTask_004, TestSize.Level1)
186 {
187 SLOGD("AVSessionItem_DestroyTask_004 begin!");
188 g_AVSessionItem->descriptor_.sessionTag_ = "TestSession";
189 g_AVSessionItem->castHandle_ = 1;
190 int32_t result = g_AVSessionItem->DestroyTask(false);
191 EXPECT_EQ(result, AVSESSION_SUCCESS);
192 SLOGD("AVSessionItem_DestroyTask_004 end!");
193 }
194
195 /**
196 * @tc.name: AVSessionItem_SetAVCallMetaData_001
197 * @tc.desc: Test SetAVCallMetaData with valid media image in AVCallMetaData.
198 * @tc.type: FUNC
199 * @tc.require: #I5Y4MZ
200 */
201 HWTEST_F(AVsessionItemTest, AVSessionItem_SetAVCallMetaData_001, TestSize.Level1)
202 {
203 SLOGD("AVSessionItem_SetAVCallMetaData_001 begin!");
204 OHOS::AVSession::AVCallMetaData avCallMetaData;
205 std::shared_ptr<AVSessionPixelMap> innerPixelMap = std::make_shared<AVSessionPixelMap>();
206 avCallMetaData.SetMediaImage(innerPixelMap);
207 int32_t result = g_AVSessionItem->SetAVCallMetaData(avCallMetaData);
208 EXPECT_EQ(result, AVSESSION_SUCCESS);
209 SLOGD("AVSessionItem_SetAVCallMetaData_001 end!");
210 }
211
212 /**
213 * @tc.name: AVSessionItem_SetAVCallMetaData_002
214 * @tc.desc: Test SetAVCallMetaData with no valid controllers in the controllers list.
215 * @tc.type: FUNC
216 * @tc.require: #I5Y4MZ
217 */
218 HWTEST_F(AVsessionItemTest, AVSessionItem_SetAVCallMetaData_002, TestSize.Level1)
219 {
220 SLOGD("AVSessionItem_SetAVCallMetaData_002 begin!");
221 g_AVSessionItem->controllers_.clear();
222 OHOS::AVSession::AVCallMetaData avCallMetaData;
223 avCallMetaData.SetName("TestName");
224 avCallMetaData.SetPhoneNumber("123456789");
225 int32_t result = g_AVSessionItem->SetAVCallMetaData(avCallMetaData);
226 EXPECT_EQ(result, AVSESSION_SUCCESS);
227 SLOGD("AVSessionItem_SetAVCallMetaData_002 end!");
228 }
229
230 /**
231 * @tc.name: AVSessionItem_SetLaunchAbility_001
232 * @tc.desc: Test SetLaunchAbility with want being nullptr.
233 * @tc.type: FUNC
234 * @tc.require: #I5Y4MZ
235 */
236 HWTEST_F(AVsessionItemTest, AVSessionItem_SetLaunchAbility_001, TestSize.Level1)
237 {
238 SLOGD("AVSessionItem_SetLaunchAbility_001 begin!");
239 OHOS::AbilityRuntime::WantAgent::WantAgent ability;
240 int32_t result = g_AVSessionItem->SetLaunchAbility(ability);
241 EXPECT_EQ(result, AVSESSION_SUCCESS);
242 SLOGD("AVSessionItem_SetLaunchAbility_001 end!");
243 }
244
245 /**
246 * @tc.name: AVSessionItem_SetLaunchAbility_003
247 * @tc.desc: Test SetLaunchAbility with valid want and launWantAgent.
248 * @tc.type: FUNC
249 * @tc.require: #I5Y4MZ
250 */
251 HWTEST_F(AVsessionItemTest, AVSessionItem_SetLaunchAbility_003, TestSize.Level1)
252 {
253 SLOGD("AVSessionItem_SetLaunchAbility_003 begin!");
254 OHOS::AbilityRuntime::WantAgent::WantAgent ability;
255 std::shared_ptr<OHOS::AbilityRuntime::WantAgent::WantAgent> launWantAgent =
256 std::make_shared<OHOS::AbilityRuntime::WantAgent::WantAgent>(ability);
257 int32_t result = g_AVSessionItem->SetLaunchAbility(ability);
258 EXPECT_EQ(result, AVSESSION_SUCCESS);
259 SLOGD("AVSessionItem_SetLaunchAbility_003 end!");
260 }
261
262 /**
263 * @tc.name: AVSessionItem_Activate_001
264 * @tc.desc: Test Activate with valid controllers.
265 * @tc.type: FUNC
266 * @tc.require: #I5Y4MZ
267 */
268 HWTEST_F(AVsessionItemTest, AVSessionItem_Activate_001, TestSize.Level1)
269 {
270 SLOGD("AVSessionItem_Activate_001 begin!");
271 OHOS::sptr<AVControllerItem> controller = g_AVControllerItem;
272 g_AVSessionItem->controllers_[controller->GetPid()] = controller;
273 int32_t result = g_AVSessionItem->Activate();
274 EXPECT_EQ(result, AVSESSION_SUCCESS);
275 SLOGD("AVSessionItem_Activate_001 end!");
276 }
277
278 /**
279 * @tc.name: AVSessionItem_Activate_002
280 * @tc.desc: Test Activate with session type not being voice or video call.
281 * @tc.type: FUNC
282 * @tc.require: #I5Y4MZ
283 */
284 HWTEST_F(AVsessionItemTest, AVSessionItem_Activate_002, TestSize.Level1)
285 {
286 SLOGD("AVSessionItem_Activate_002 begin!");
287 g_AVSessionItem->descriptor_.sessionType_ = AVSession::SESSION_TYPE_VOICE_CALL;
288 int32_t result = g_AVSessionItem->Activate();
289 EXPECT_EQ(result, AVSESSION_SUCCESS);
290 SLOGD("AVSessionItem_Activate_002 end!");
291 }
292
293 /**
294 * @tc.name: AVSessionItem_Activate_003
295 * @tc.desc: Test Activate with session type being voice or video call.
296 * @tc.type: FUNC
297 * @tc.require: #I5Y4MZ
298 */
299 HWTEST_F(AVsessionItemTest, AVSessionItem_Activate_003, TestSize.Level1)
300 {
301 SLOGD("AVSessionItem_Activate_003 begin!");
302 g_AVSessionItem->descriptor_.sessionType_ = AVSession::SESSION_TYPE_VIDEO_CALL;
303 int32_t result = g_AVSessionItem->Activate();
304 EXPECT_EQ(result, AVSESSION_SUCCESS);
305 SLOGD("AVSessionItem_Activate_003 end!");
306 }
307
308 /**
309 * @tc.name: AVSessionItem_GetAnonymousDeviceId_001
310 * @tc.desc: Test GetAnonymousDeviceId with empty deviceId.
311 * @tc.type: FUNC
312 * @tc.require: #I5Y4MZ
313 */
314 HWTEST_F(AVsessionItemTest, AVSessionItem_GetAnonymousDeviceId_001, TestSize.Level1)
315 {
316 SLOGD("AVSessionItem_GetAnonymousDeviceId_001 begin!");
317 std::string deviceId = "";
318 std::string result = g_AVSessionItem->GetAnonymousDeviceId(deviceId);
319 EXPECT_EQ(result, "unknown");
320 SLOGD("AVSessionItem_GetAnonymousDeviceId_001 end!");
321 }
322
323 /**
324 * @tc.name: AVSessionItem_GetAnonymousDeviceId_002
325 * @tc.desc: Test GetAnonymousDeviceId with deviceId length less than DEVICE_ID_MIN_LEN.
326 * @tc.type: FUNC
327 * @tc.require: #I5Y4MZ
328 */
329 HWTEST_F(AVsessionItemTest, AVSessionItem_GetAnonymousDeviceId_002, TestSize.Level1)
330 {
331 SLOGD("AVSessionItem_GetAnonymousDeviceId_002 begin!");
332 std::string deviceId = "12345";
333 std::string result = g_AVSessionItem->GetAnonymousDeviceId(deviceId);
334 EXPECT_EQ(result, "unknown");
335 SLOGD("AVSessionItem_GetAnonymousDeviceId_002 end!");
336 }
337
338 /**
339 * @tc.name: AVSessionItem_GetAnonymousDeviceId_003
340 * @tc.desc: Test GetAnonymousDeviceId with deviceId length greater than or equal to DEVICE_ID_MIN_LEN.
341 * @tc.type: FUNC
342 * @tc.require: #I5Y4MZ
343 */
344 HWTEST_F(AVsessionItemTest, AVSessionItem_GetAnonymousDeviceId_003, TestSize.Level1)
345 {
346 SLOGD("AVSessionItem_GetAnonymousDeviceId_003 begin!");
347 std::string deviceId = "1234567890";
348 std::string result = g_AVSessionItem->GetAnonymousDeviceId(deviceId);
349 EXPECT_NE(result, "unknown");
350 SLOGD("AVSessionItem_GetAnonymousDeviceId_003 end!");
351 }
352
353 /**
354 * @tc.name: AVSessionItem_RegisterListenerStreamToCast_001
355 * @tc.desc: Test RegisterListenerStreamToCast with castHandle_ > 0.
356 * @tc.type: FUNC
357 * @tc.require: #I5Y4MZ
358 */
359 HWTEST_F(AVsessionItemTest, AVSessionItem_RegisterListenerStreamToCast_001, TestSize.Level1)
360 {
361 SLOGD("AVSessionItem_RegisterListenerStreamToCast_001 begin!");
362 g_AVSessionItem->castHandle_ = 1;
363 std::pair<std::string, std::string> serviceNameStatePair;
364 DeviceInfo deviceInfo;
365 deviceInfo.deviceId_ = "1234567890";
366 deviceInfo.deviceName_ = "TestDevice";
367 deviceInfo.deviceType_ = 1;
368 deviceInfo.networkId_ = "12345";
369 deviceInfo.supportedProtocols_ = 2;
370 int32_t result = g_AVSessionItem->RegisterListenerStreamToCast(serviceNameStatePair, deviceInfo);
371 EXPECT_EQ(result, AVSESSION_ERROR);
372 SLOGD("AVSessionItem_RegisterListenerStreamToCast_001 end!");
373 }
374
375 /**
376 * @tc.name: AVSessionItem_RegisterListenerStreamToCast_002
377 * @tc.desc: Test RegisterListenerStreamToCast with GetMirrorCastHandle() == -1.
378 * @tc.type: FUNC
379 * @tc.require: #I5Y4MZ
380 */
381 HWTEST_F(AVsessionItemTest, AVSessionItem_RegisterListenerStreamToCast_002, TestSize.Level1)
382 {
383 SLOGD("AVSessionItem_RegisterListenerStreamToCast_002 begin!");
384 g_AVSessionItem->castHandle_ = AVSESSION_ERROR;
385 std::pair<std::string, std::string> serviceNameStatePair;
386 DeviceInfo deviceInfo;
387 deviceInfo.deviceId_ = "1234567890";
388 deviceInfo.deviceName_ = "TestDevice";
389 deviceInfo.deviceType_ = 1;
390 deviceInfo.networkId_ = "12345";
391 deviceInfo.supportedProtocols_ = 2;
392 int32_t result = g_AVSessionItem->RegisterListenerStreamToCast(serviceNameStatePair, deviceInfo);
393 EXPECT_EQ(result, AVSESSION_SUCCESS);
394 SLOGD("AVSessionItem_RegisterListenerStreamToCast_002 end!");
395 }
396
397 /**
398 * @tc.name: AVSessionItem_RegisterListenerStreamToCast_003
399 * @tc.desc: Test RegisterListenerStreamToCast with castControllerProxy_ and GetDescription() != nullptr.
400 * @tc.type: FUNC
401 * @tc.require: #I5Y4MZ
402 */
403 HWTEST_F(AVsessionItemTest, AVSessionItem_RegisterListenerStreamToCast_003, TestSize.Level1)
404 {
405 SLOGD("AVSessionItem_RegisterListenerStreamToCast_003 begin!");
406 g_AVSessionItem->castHandle_ = 0;
407 std::pair<std::string, std::string> serviceNameStatePair;
408 DeviceInfo deviceInfo;
409 deviceInfo.deviceId_ = "1234567890";
410 deviceInfo.deviceName_ = "TestDevice";
411 deviceInfo.deviceType_ = 1;
412 deviceInfo.networkId_ = "12345";
413 deviceInfo.supportedProtocols_ = 2;
414
415 auto mockCastControllerProxy = std::make_shared<MockIAVCastControllerProxy>();
416 g_AVSessionItem->castControllerProxy_ = mockCastControllerProxy;
417 int32_t result = g_AVSessionItem->RegisterListenerStreamToCast(serviceNameStatePair, deviceInfo);
418 EXPECT_EQ(result, AVSESSION_SUCCESS);
419 SLOGD("AVSessionItem_RegisterListenerStreamToCast_003 end!");
420 }
421
422
423 /**
424 * @tc.name: AVSessionItem_RegisterListenerStreamToCast_004
425 * @tc.desc: Test RegisterListenerStreamToCast with castControllerProxy_ == nullptr and castHandle_ <= 0.
426 * @tc.type: FUNC
427 * @tc.require: #I5Y4MZ
428 */
429 HWTEST_F(AVsessionItemTest, AVSessionItem_RegisterListenerStreamToCast_004, TestSize.Level1)
430 {
431 SLOGD("AVSessionItem_RegisterListenerStreamToCast_004 begin!");
432 g_AVSessionItem->castHandle_ = 0;
433 std::pair<std::string, std::string> serviceNameStatePair;
434 DeviceInfo deviceInfo;
435 deviceInfo.deviceId_ = "1234567890";
436 deviceInfo.deviceName_ = "TestDevice";
437 deviceInfo.deviceType_ = 1;
438 deviceInfo.networkId_ = "12345";
439 deviceInfo.supportedProtocols_ = 2;
440 g_AVSessionItem->castControllerProxy_ = nullptr;
441 int32_t result = g_AVSessionItem->RegisterListenerStreamToCast(serviceNameStatePair, deviceInfo);
442 EXPECT_EQ(result, AVSESSION_SUCCESS);
443 SLOGD("AVSessionItem_RegisterListenerStreamToCast_004 end!");
444 }
445
446 /**
447 * @tc.name: AVSessionItem_RegisterListenerStreamToCast_005
448 * @tc.desc: Test RegisterListenerStreamToCast with GetCurrentItem().GetDescription() == nullptr and castHandle_ <= 0.
449 * @tc.type: FUNC
450 * @tc.require: #I5Y4MZ
451 */
452 HWTEST_F(AVsessionItemTest, AVSessionItem_RegisterListenerStreamToCast_005, TestSize.Level1)
453 {
454 SLOGD("AVSessionItem_RegisterListenerStreamToCast_005 begin!");
455 g_AVSessionItem->castHandle_ = 0;
456 std::pair<std::string, std::string> serviceNameStatePair;
457 DeviceInfo deviceInfo;
458 deviceInfo.deviceId_ = "1234567890";
459 deviceInfo.deviceName_ = "TestDevice";
460 deviceInfo.deviceType_ = 1;
461 deviceInfo.networkId_ = "12345";
462 deviceInfo.supportedProtocols_ = 2;
463
464 auto mockCastControllerProxy = std::make_shared<MockIAVCastControllerProxy>();
465 g_AVSessionItem->castControllerProxy_ = mockCastControllerProxy;
466 AVQueueItem item;
467 item.description_ = nullptr;
468 int32_t result = g_AVSessionItem->RegisterListenerStreamToCast(serviceNameStatePair, deviceInfo);
469 EXPECT_EQ(result, AVSESSION_SUCCESS);
470 SLOGD("AVSessionItem_RegisterListenerStreamToCast_005 end!");
471 }
472
473
474 /**
475 * @tc.name: AVSessionItem_SetOutputDevice_001
476 * @tc.desc: Test SetOutputDevice with controllers not empty.
477 * @tc.type: FUNC
478 * @tc.require: #I5Y4MZ
479 */
480 HWTEST_F(AVsessionItemTest, AVSessionItem_SetOutputDevice_001, TestSize.Level1)
481 {
482 SLOGD("AVSessionItem_SetOutputDevice_001 begin!");
483 OutputDeviceInfo info;
484 DeviceInfo deviceInfo;
485 deviceInfo.deviceId_ = "DeviceId1";
486 deviceInfo.deviceName_ = "DeviceName1";
487 deviceInfo.deviceType_ = 1;
488 info.deviceInfos_.push_back(deviceInfo);
489 OHOS::sptr<AVControllerItem> controller = new AVControllerItem(1, g_AVSessionItem);
490 g_AVSessionItem->SetOutputDevice(info);
491 EXPECT_TRUE(g_AVSessionItem->descriptor_.outputDeviceInfo_.deviceInfos_[0].deviceId_ == "DeviceId1");
492 EXPECT_TRUE(g_AVSessionItem->descriptor_.outputDeviceInfo_.deviceInfos_[0].deviceName_ == "DeviceName1");
493 EXPECT_TRUE(g_AVSessionItem->descriptor_.outputDeviceInfo_.deviceInfos_[0].deviceType_ == 1);
494 SLOGD("AVSessionItem_SetOutputDevice_001 end!");
495 }
496
497 /**
498 * @tc.name: AVSessionItem_SetOutputDevice_002
499 * @tc.desc: Test SetOutputDevice with controllers empty.
500 * @tc.type: FUNC
501 * @tc.require: #I5Y4MZ
502 */
503 HWTEST_F(AVsessionItemTest, AVSessionItem_SetOutputDevice_002, TestSize.Level1)
504 {
505 SLOGD("AVSessionItem_SetOutputDevice_002 begin!");
506 OutputDeviceInfo info;
507 DeviceInfo deviceInfo;
508 deviceInfo.deviceId_ = "DeviceId1";
509 deviceInfo.deviceName_ = "DeviceName1";
510 deviceInfo.deviceType_ = 1;
511 info.deviceInfos_.push_back(deviceInfo);
512 g_AVSessionItem->controllers_.clear();
513 g_AVSessionItem->SetOutputDevice(info);
514 EXPECT_TRUE(g_AVSessionItem->descriptor_.outputDeviceInfo_.deviceInfos_[0].deviceId_ == "DeviceId1");
515 EXPECT_TRUE(g_AVSessionItem->descriptor_.outputDeviceInfo_.deviceInfos_[0].deviceName_ == "DeviceName1");
516 EXPECT_TRUE(g_AVSessionItem->descriptor_.outputDeviceInfo_.deviceInfos_[0].deviceType_ == 1);
517 SLOGD("AVSessionItem_SetOutputDevice_002 end!");
518 }