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 "avrouter_impl.h"
18 #include "avsession_errors.h"
19 #include "avsession_log.h"
20 #include "avsession_service.h"
21 #include "hw_cast_provider.h"
22
23 using namespace testing::ext;
24 namespace OHOS {
25 namespace AVSession {
26
27 static std::shared_ptr<AVSessionService> g_AVSessionService {nullptr};
28 static std::shared_ptr<AVRouterImpl> g_AVRouterImpl {nullptr};
29
30 class AVRouterImplMock : public AVRouterImpl {
31 public:
AVRouterImplMock()32 AVRouterImplMock() : AVRouterImpl() {}
~AVRouterImplMock()33 virtual ~AVRouterImplMock() {}
34 };
35
36 class AVCastControllerProxyMock : public IAVCastControllerProxy {
37 public:
Release()38 void Release() {};
RegisterControllerListener(const std::shared_ptr<IAVCastControllerProxyListener> iAVCastControllerProxyListener)39 int32_t RegisterControllerListener(const std::shared_ptr<IAVCastControllerProxyListener>
40 iAVCastControllerProxyListener) {return 0;}
UnRegisterControllerListener(const std::shared_ptr<IAVCastControllerProxyListener> iAVCastControllerProxyListener)41 int32_t UnRegisterControllerListener(const std::shared_ptr<IAVCastControllerProxyListener>
42 iAVCastControllerProxyListener) {return 0;}
GetCurrentItem()43 AVQueueItem GetCurrentItem() {return AVQueueItem();}
Start(const AVQueueItem & avQueueItem)44 int32_t Start(const AVQueueItem& avQueueItem) {return 0;}
Prepare(const AVQueueItem & avQueueItem)45 int32_t Prepare(const AVQueueItem& avQueueItem) {return 0;}
SendControlCommand(const AVCastControlCommand cmd)46 void SendControlCommand(const AVCastControlCommand cmd) {}
GetDuration(int32_t & duration)47 int32_t GetDuration(int32_t& duration) {return 0;}
GetCastAVPlaybackState(AVPlaybackState & avPlaybackState)48 int32_t GetCastAVPlaybackState(AVPlaybackState& avPlaybackState) {return 0;}
SetValidAbility(const std::vector<int32_t> & validAbilityList)49 int32_t SetValidAbility(const std::vector<int32_t>& validAbilityList) {return 0;}
GetValidAbility(std::vector<int32_t> & validAbilityList)50 int32_t GetValidAbility(std::vector<int32_t> &validAbilityList) {return 0;}
SetDisplaySurface(std::string & surfaceId)51 int32_t SetDisplaySurface(std::string& surfaceId) {return 0;}
ProcessMediaKeyResponse(const std::string & assetId,const std::vector<uint8_t> & response)52 int32_t ProcessMediaKeyResponse(const std::string& assetId, const std::vector<uint8_t>& response) {return 0;}
GetSupportedDecoders(std::vector<std::string> & decoderTypes)53 int32_t GetSupportedDecoders(std::vector<std::string>& decoderTypes) {return 0;}
GetRecommendedResolutionLevel(std::string & decoderType,ResolutionLevel & resolutionLevel)54 int32_t GetRecommendedResolutionLevel(std::string& decoderType, ResolutionLevel& resolutionLevel) {return 0;}
GetSupportedHdrCapabilities(std::vector<HDRFormat> & hdrFormats)55 int32_t GetSupportedHdrCapabilities(std::vector<HDRFormat>& hdrFormats) {return 0;}
GetSupportedPlaySpeeds(std::vector<float> & playSpeeds)56 int32_t GetSupportedPlaySpeeds(std::vector<float>& playSpeeds) {return 0;}
RefreshCurrentAVQueueItem(const AVQueueItem & avQueueItem)57 int32_t RefreshCurrentAVQueueItem(const AVQueueItem& avQueueItem) {return 0;}
SetSessionCallbackForCastCap(const std::function<void (bool,bool)> & callback)58 void SetSessionCallbackForCastCap(const std::function<void(bool, bool)>& callback) {}
SetSpid(uint32_t spid)59 void SetSpid(uint32_t spid) {}
60 };
61
62 class AVRouterImplTest : public testing::Test {
63 public:
64 static void SetUpTestCase();
65 static void TearDownTestCase();
66 void SetUp() override;
67 void TearDown() override;
68 };
69
SetUpTestCase()70 void AVRouterImplTest::SetUpTestCase()
71 {
72 SLOGI("set up AVSessionServiceTest");
73 system("killall -9 com.example.hiMusicDemo");
74 g_AVSessionService = std::make_shared<AVSessionService>(OHOS::AVSESSION_SERVICE_ID);
75 g_AVRouterImpl = std::make_shared<AVRouterImplMock>();
76 g_AVRouterImpl->Init(g_AVSessionService.get());
77 }
78
TearDownTestCase()79 void AVRouterImplTest::TearDownTestCase()
80 {
81 g_AVRouterImpl->Release();
82 g_AVSessionService->Close();
83 }
84
SetUp()85 void AVRouterImplTest::SetUp() {}
86
TearDown()87 void AVRouterImplTest::TearDown() {}
88
89 class AVRouterListenerMock : public IAVRouterListener {
90 public:
OnCastStateChange(int32_t castState,DeviceInfo deviceInfo,bool isNeedRemove)91 virtual void OnCastStateChange(int32_t castState, DeviceInfo deviceInfo, bool isNeedRemove) {}
92
OnCastEventRecv(int32_t errorCode,std::string & errorMsg)93 virtual void OnCastEventRecv(int32_t errorCode, std::string& errorMsg) {}
94
~AVRouterListenerMock()95 virtual ~AVRouterListenerMock() {}
96 };
97
98 class AVSessionServiceListenerMock : public IAVSessionServiceListener {
99 public:
100 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
ReleaseCastSession()101 void ReleaseCastSession() {}
CreateSessionByCast(const int64_t castHandle)102 void CreateSessionByCast(const int64_t castHandle) {}
NotifyDeviceAvailable(const OutputDeviceInfo & castOutputDeviceInfo)103 void NotifyDeviceAvailable(const OutputDeviceInfo& castOutputDeviceInfo) {}
NotifyDeviceLogEvent(const DeviceLogEventCode eventId,const int64_t param)104 void NotifyDeviceLogEvent(const DeviceLogEventCode eventId, const int64_t param) {}
NotifyDeviceOffline(const std::string & deviceId)105 void NotifyDeviceOffline(const std::string& deviceId) {}
NotifyDeviceStateChange(const DeviceState & deviceState)106 void NotifyDeviceStateChange(const DeviceState& deviceState) {}
setInCast(bool isInCast)107 void setInCast(bool isInCast) {}
SetIsSupportMirrorToStream(bool isSupportMirrorToStream)108 void SetIsSupportMirrorToStream(bool isSupportMirrorToStream) {}
checkEnableCast(bool enable)109 int32_t checkEnableCast(bool enable) { return 0; }
110 #endif
~AVSessionServiceListenerMock()111 virtual ~AVSessionServiceListenerMock() {}
112 };
113
114 /**
115 * @tc.name: GetRemoteController001
116 * @tc.desc: get controller by handle
117 * @tc.type: FUNC
118 * @tc.require: NA
119 */
120 static HWTEST_F(AVRouterImplTest, GetRemoteController001, TestSize.Level0)
121 {
122 SLOGI("GetRemoteController001 begin");
123 int32_t num = g_AVRouterImpl->providerNumber_;
124 int64_t castHandle = static_cast<int64_t>((static_cast<uint64_t>(num) << 32) |
125 static_cast<uint32_t>(num));
126 auto controller = g_AVRouterImpl->GetRemoteController(castHandle);
127 EXPECT_TRUE(controller == nullptr);
128 SLOGI("GetRemoteController001 end");
129 }
130
131 /**
132 * @tc.name: GetRemoteController002
133 * @tc.desc: get controller by handle
134 * @tc.type: FUNC
135 * @tc.require: NA
136 */
137 static HWTEST_F(AVRouterImplTest, GetRemoteController002, TestSize.Level0)
138 {
139 SLOGI("GetRemoteController002 begin");
140 int32_t num = g_AVRouterImpl->providerNumber_;
141 g_AVRouterImpl->providerManagerMap_[num] = nullptr;
142 int64_t castHandle = static_cast<int64_t>((static_cast<uint64_t>(num) << 32) |
143 static_cast<uint32_t>(num));
144 auto controller = g_AVRouterImpl->GetRemoteController(castHandle);
145 EXPECT_TRUE(controller == nullptr);
146 SLOGI("GetRemoteController002 end");
147 }
148
149 /**
150 * @tc.name: StartCast001
151 * @tc.desc: sessinId have existed in castHandleToInfoMap_
152 * @tc.type: FUNC
153 * @tc.require: NA
154 */
155 static HWTEST_F(AVRouterImplTest, StartCast001, TestSize.Level0)
156 {
157 SLOGI("StartCast001 begin");
158 OutputDeviceInfo outputDeviceInfo;
159 DeviceInfo deviceInfo;
160 deviceInfo.providerId_ = g_AVRouterImpl->providerNumber_;
161 outputDeviceInfo.deviceInfos_.push_back(deviceInfo);
162 std::pair<std::string, std::string> serviceNameStatePair;
163 std::string sessionId = "1000";
164
165 int32_t number = 10;
166 AVRouter::CastHandleInfo castHandleInfo;
167 castHandleInfo.outputDeviceInfo_ = outputDeviceInfo;
168 castHandleInfo.sessionId_ = sessionId;
169 g_AVRouterImpl->castHandleToInfoMap_.insert({number, castHandleInfo});
170
171 auto ret = g_AVRouterImpl->StartCast(outputDeviceInfo, serviceNameStatePair, sessionId);
172 EXPECT_TRUE(ret == AVSESSION_ERROR);
173 SLOGI("StartCast001 end");
174 }
175
176 /**
177 * @tc.name: StartCast002
178 * @tc.desc: castHandleInfo.outputDeviceInfo_.deviceInfos_.size() equl to 0
179 * @tc.type: FUNC
180 * @tc.require: NA
181 */
182 static HWTEST_F(AVRouterImplTest, StartCast002, TestSize.Level0)
183 {
184 SLOGI("StartCast002 begin");
185 OutputDeviceInfo outputDeviceInfo;
186 DeviceInfo deviceInfo;
187 deviceInfo.providerId_ = g_AVRouterImpl->providerNumber_;
188 outputDeviceInfo.deviceInfos_.push_back(deviceInfo);
189 std::pair<std::string, std::string> serviceNameStatePair;
190 std::string sessionId = "1000";
191
192 AVRouter::CastHandleInfo castHandleInfo;
193 castHandleInfo.sessionId_ = "1001";
194 int32_t number = 11;
195 g_AVRouterImpl->castHandleToInfoMap_.insert({number, castHandleInfo});
196
197 auto ret = g_AVRouterImpl->StartCast(outputDeviceInfo, serviceNameStatePair, sessionId);
198 EXPECT_TRUE(ret == AVSESSION_ERROR);
199 SLOGI("StartCast002 end");
200 }
201
202 /**
203 * @tc.name: StartCast003
204 * @tc.desc: success to find deviceId in castHandleToInfoMap_
205 * @tc.type: FUNC
206 * @tc.require: NA
207 */
208 static HWTEST_F(AVRouterImplTest, StartCast003, TestSize.Level0)
209 {
210 SLOGI("StartCast003 begin");
211 OutputDeviceInfo outputDeviceInfo;
212 DeviceInfo deviceInfo;
213 deviceInfo.providerId_ = g_AVRouterImpl->providerNumber_;
214 outputDeviceInfo.deviceInfos_.push_back(deviceInfo);
215 std::pair<std::string, std::string> serviceNameStatePair;
216 std::string sessionId = "1000";
217
218 AVRouter::CastHandleInfo castHandleInfo;
219 castHandleInfo.sessionId_ = "1001";
220 castHandleInfo.outputDeviceInfo_ = outputDeviceInfo;
221 int32_t number = 11;
222 g_AVRouterImpl->castHandleToInfoMap_.insert({number, castHandleInfo});
223
224 auto ret = g_AVRouterImpl->StartCast(outputDeviceInfo, serviceNameStatePair, sessionId);
225 EXPECT_TRUE(ret == AVSESSION_ERROR);
226 SLOGI("StartCast003 end");
227 }
228
229 /**
230 * @tc.name: AddDevice001
231 * @tc.desc: success to add device
232 * @tc.type: FUNC
233 * @tc.require: NA
234 */
235 static HWTEST_F(AVRouterImplTest, AddDevice001, TestSize.Level0)
236 {
237 SLOGI("AddDevice001 begin");
238 int32_t tempId = g_AVRouterImpl->providerNumber_;
239 OutputDeviceInfo outputDeviceInfo;
240 DeviceInfo deviceInfo;
241 deviceInfo.providerId_ = tempId;
242 outputDeviceInfo.deviceInfos_.push_back(deviceInfo);
243
244 int32_t castId = 1;
245 uint32_t spid = 33;
246 int64_t castHandle = static_cast<int64_t>((static_cast<uint64_t>(tempId) << 32) |
247 static_cast<uint32_t>(castId));
248
249 AVRouter::CastHandleInfo castHandleInfo;
250 castHandleInfo.outputDeviceInfo_ = outputDeviceInfo;
251 g_AVRouterImpl->castHandleToInfoMap_.insert({castHandle, castHandleInfo});
252
253 int32_t ret = g_AVRouterImpl->AddDevice(castId, outputDeviceInfo, spid);
254 EXPECT_TRUE(ret == AVSESSION_SUCCESS);
255 SLOGI("AddDevice001 end");
256 }
257
258 /**
259 * @tc.name: AddDevice002
260 * @tc.desc: fail to add device
261 * @tc.type: FUNC
262 * @tc.require: NA
263 */
264 static HWTEST_F(AVRouterImplTest, AddDevice002, TestSize.Level0)
265 {
266 SLOGI("AddDevice002 begin");
267 int32_t tempId = g_AVRouterImpl->providerNumber_;
268 OutputDeviceInfo outputDeviceInfo;
269 DeviceInfo deviceInfo;
270 deviceInfo.providerId_ = tempId;
271 outputDeviceInfo.deviceInfos_.push_back(deviceInfo);
272
273 int32_t castId = 1;
274 uint32_t spid = 33;
275 int64_t castHandle = static_cast<int64_t>((static_cast<uint64_t>(tempId) << 32) |
276 static_cast<uint32_t>(castId));
277
278 AVRouter::CastHandleInfo castHandleInfo;
279 castHandleInfo.outputDeviceInfo_ = outputDeviceInfo;
280 g_AVRouterImpl->castHandleToInfoMap_.insert({castHandle + 100, castHandleInfo});
281
282 int32_t ret = g_AVRouterImpl->AddDevice(castId, outputDeviceInfo, spid);
283 EXPECT_TRUE(ret == AVSESSION_SUCCESS);
284 SLOGI("AddDevice002 end");
285 }
286
287 /**
288 * @tc.name: AddDevice003
289 * @tc.desc: fail to add device
290 * @tc.type: FUNC
291 * @tc.require: NA
292 */
293 static HWTEST_F(AVRouterImplTest, AddDevice003, TestSize.Level0)
294 {
295 SLOGI("AddDevice003 begin");
296 int32_t tempId = g_AVRouterImpl->providerNumber_;
297 OutputDeviceInfo outputDeviceInfo;
298 DeviceInfo deviceInfo;
299 deviceInfo.providerId_ = tempId;
300 outputDeviceInfo.deviceInfos_.push_back(deviceInfo);
301
302 int32_t castId = 1;
303 uint32_t spid = 33;
304 int64_t castHandle = static_cast<int64_t>((static_cast<uint64_t>(tempId) << 32) |
305 static_cast<uint32_t>(castId));
306
307 AVRouter::CastHandleInfo castHandleInfo;
308 g_AVRouterImpl->castHandleToInfoMap_.insert({castHandle, castHandleInfo});
309
310 int32_t ret = g_AVRouterImpl->AddDevice(castId, outputDeviceInfo, spid);
311 EXPECT_TRUE(ret == AVSESSION_SUCCESS);
312 SLOGI("AddDevice003 end");
313 }
314
315 /**
316 * @tc.name: AddDevice004
317 * @tc.desc: fail to add device
318 * @tc.type: FUNC
319 * @tc.require: NA
320 */
321 static HWTEST_F(AVRouterImplTest, AddDevice004, TestSize.Level0)
322 {
323 SLOGI("AddDevice004 begin");
324 int32_t tempId = g_AVRouterImpl->providerNumber_;
325 OutputDeviceInfo outputDeviceInfo;
326 DeviceInfo deviceInfo;
327 deviceInfo.providerId_ = tempId;
328 outputDeviceInfo.deviceInfos_.push_back(deviceInfo);
329
330 int32_t castId = 1;
331 uint32_t spid = 33;
332 int64_t castHandle = static_cast<int64_t>((static_cast<uint64_t>(tempId) << 32) |
333 static_cast<uint32_t>(castId));
334
335 OutputDeviceInfo outputDeviceInfo2;
336 DeviceInfo deviceInfo2;
337 deviceInfo2.providerId_ = 12321;
338 outputDeviceInfo2.deviceInfos_.push_back(deviceInfo2);
339
340 AVRouter::CastHandleInfo castHandleInfo;
341 castHandleInfo.outputDeviceInfo_ = outputDeviceInfo2;
342 g_AVRouterImpl->castHandleToInfoMap_.insert({castHandle, castHandleInfo});
343
344 int32_t ret = g_AVRouterImpl->AddDevice(castId, outputDeviceInfo, spid);
345 EXPECT_TRUE(ret == AVSESSION_SUCCESS);
346 SLOGI("AddDevice004 end");
347 }
348
349 /**
350 * @tc.name: SetServiceAllConnectState001
351 * @tc.desc: success to set connect state
352 * @tc.type: FUNC
353 * @tc.require: NA
354 */
355 static HWTEST_F(AVRouterImplTest, SetServiceAllConnectState001, TestSize.Level0)
356 {
357 SLOGI("SetServiceAllConnectState001 begin");
358 int32_t providerNumber = g_AVRouterImpl->providerNumber_;
359 int32_t castId = 1;
360 int64_t castHandle = static_cast<int64_t>((static_cast<uint64_t>(providerNumber) << 32) |
361 static_cast<uint32_t>(castId));
362
363 OutputDeviceInfo outputDeviceInfo;
364 DeviceInfo deviceInfo;
365 deviceInfo.providerId_ = providerNumber;
366 outputDeviceInfo.deviceInfos_.push_back(deviceInfo);
367
368 AVRouter::CastHandleInfo castHandleInfo;
369 castHandleInfo.outputDeviceInfo_ = outputDeviceInfo;
370 g_AVRouterImpl->castHandleToInfoMap_.insert({castHandle, castHandleInfo});
371
372 int32_t ret = g_AVRouterImpl->SetServiceAllConnectState(castId, deviceInfo);
373 EXPECT_TRUE(ret == AVSESSION_ERROR);
374 SLOGI("SetServiceAllConnectState001 end");
375 }
376
377 /**
378 * @tc.name: SetServiceAllConnectState002
379 * @tc.desc: fail to set connect state
380 * @tc.type: FUNC
381 * @tc.require: NA
382 */
383 static HWTEST_F(AVRouterImplTest, SetServiceAllConnectState002, TestSize.Level0)
384 {
385 SLOGI("SetServiceAllConnectState002 begin");
386 int32_t providerNumber = g_AVRouterImpl->providerNumber_;
387 int32_t castId = 1;
388 int64_t castHandle = static_cast<int64_t>((static_cast<uint64_t>(providerNumber) << 32) |
389 static_cast<uint32_t>(castId));
390
391 OutputDeviceInfo outputDeviceInfo;
392 DeviceInfo deviceInfo;
393 deviceInfo.providerId_ = providerNumber;
394 outputDeviceInfo.deviceInfos_.push_back(deviceInfo);
395
396 AVRouter::CastHandleInfo castHandleInfo;
397 castHandleInfo.outputDeviceInfo_ = outputDeviceInfo;
398 g_AVRouterImpl->castHandleToInfoMap_.insert({castHandle + 100, castHandleInfo});
399
400 int32_t ret = g_AVRouterImpl->SetServiceAllConnectState(castId, deviceInfo);
401 EXPECT_TRUE(ret == AVSESSION_ERROR);
402 SLOGI("SetServiceAllConnectState002 end");
403 }
404
405 /**
406 * @tc.name: OnCastStateChange001
407 * @tc.desc: set castState is disconnectStateFromCast_
408 * @tc.type: FUNC
409 * @tc.require: NA
410 */
411 static HWTEST_F(AVRouterImplTest, OnCastStateChange001, TestSize.Level0)
412 {
413 SLOGI("OnCastStateChange001 begin");
414 OutputDeviceInfo outputDeviceInfo;
415 DeviceInfo deviceInfo;
416 deviceInfo.providerId_ = 1;
417 outputDeviceInfo.deviceInfos_.push_back(deviceInfo);
418
419 int64_t castHandle = 2000;
420 AVRouter::CastHandleInfo castHandleInfo;
421 castHandleInfo.outputDeviceInfo_ = outputDeviceInfo;
422 castHandleInfo.avRouterListener_ = std::make_shared<AVRouterListenerMock>();
423 g_AVRouterImpl->castHandleToInfoMap_.insert({castHandle, castHandleInfo});
424
425 int32_t castState = g_AVRouterImpl->disconnectStateFromCast_;
426 g_AVRouterImpl->OnCastStateChange(castState, deviceInfo);
427
428 EXPECT_TRUE(castHandleInfo.avRouterListener_ != nullptr);
429 SLOGI("OnCastStateChange001 end");
430 }
431
432 /**
433 * @tc.name: OnCastStateChange002
434 * @tc.desc: set castState is connectStateFromCast_
435 * @tc.type: FUNC
436 * @tc.require: NA
437 */
438 static HWTEST_F(AVRouterImplTest, OnCastStateChange002, TestSize.Level0)
439 {
440 SLOGI("OnCastStateChange002 begin");
441 OutputDeviceInfo outputDeviceInfo;
442 DeviceInfo deviceInfo;
443 deviceInfo.providerId_ = 1;
444 outputDeviceInfo.deviceInfos_.push_back(deviceInfo);
445
446 int64_t castHandle = 2000;
447 AVRouter::CastHandleInfo castHandleInfo;
448 castHandleInfo.outputDeviceInfo_ = outputDeviceInfo;
449 castHandleInfo.avRouterListener_ = std::make_shared<AVRouterListenerMock>();
450 g_AVRouterImpl->castHandleToInfoMap_.insert({castHandle, castHandleInfo});
451
452 int32_t castState = g_AVRouterImpl->connectStateFromCast_;
453 g_AVRouterImpl->OnCastStateChange(castState, deviceInfo);
454
455 EXPECT_TRUE(castHandleInfo.avRouterListener_ != nullptr);
456 SLOGI("OnCastStateChange002 end");
457 }
458
459 /**
460 * @tc.name: OnCastStateChange003
461 * @tc.desc: listener is nullptr
462 * @tc.type: FUNC
463 * @tc.require: NA
464 */
465 static HWTEST_F(AVRouterImplTest, OnCastStateChange003, TestSize.Level0)
466 {
467 SLOGI("OnCastStateChange003 begin");
468 OutputDeviceInfo outputDeviceInfo;
469 DeviceInfo deviceInfo;
470 deviceInfo.providerId_ = 1;
471 outputDeviceInfo.deviceInfos_.push_back(deviceInfo);
472
473 int64_t castHandle = 2000;
474 AVRouter::CastHandleInfo castHandleInfo;
475 castHandleInfo.outputDeviceInfo_ = outputDeviceInfo;
476 g_AVRouterImpl->castHandleToInfoMap_.insert({castHandle, castHandleInfo});
477
478 int32_t castState = g_AVRouterImpl->connectStateFromCast_;
479 g_AVRouterImpl->OnCastStateChange(castState, deviceInfo);
480
481 EXPECT_TRUE(castHandleInfo.avRouterListener_ == nullptr);
482 SLOGI("OnCastStateChange003 end");
483 }
484
485 /**
486 * @tc.name: OnCastStateChange004
487 * @tc.desc: castState is mirror to stream
488 * @tc.type: FUNC
489 * @tc.require: NA
490 */
491 static HWTEST_F(AVRouterImplTest, OnCastStateChange004, TestSize.Level0)
492 {
493 SLOGI("OnCastStateChange004 begin");
494 OutputDeviceInfo outputDeviceInfo;
495 DeviceInfo deviceInfo;
496 deviceInfo.providerId_ = 1;
497 outputDeviceInfo.deviceInfos_.push_back(deviceInfo);
498
499 int64_t castHandle = 2000;
500 AVRouter::CastHandleInfo castHandleInfo;
501 castHandleInfo.outputDeviceInfo_ = outputDeviceInfo;
502 castHandleInfo.avRouterListener_ = std::make_shared<AVRouterListenerMock>();
503 g_AVRouterImpl->castHandleToInfoMap_.insert({castHandle, castHandleInfo});
504
505 int32_t castState = 11;
506 g_AVRouterImpl->OnCastStateChange(castState, deviceInfo);
507
508 EXPECT_TRUE(g_AVRouterImpl->IsInMirrorToStreamState());
509 SLOGI("OnCastStateChange004 end");
510 }
511
512 /**
513 * @tc.name: OnCastStateChange005
514 * @tc.desc: castState is stream to mirror
515 * @tc.type: FUNC
516 * @tc.require: NA
517 */
518 static HWTEST_F(AVRouterImplTest, OnCastStateChange005, TestSize.Level0)
519 {
520 SLOGI("OnCastStateChange005 begin");
521 OutputDeviceInfo outputDeviceInfo;
522 DeviceInfo deviceInfo;
523 deviceInfo.providerId_ = 1;
524 outputDeviceInfo.deviceInfos_.push_back(deviceInfo);
525
526 int64_t castHandle = 2000;
527 AVRouter::CastHandleInfo castHandleInfo;
528 castHandleInfo.outputDeviceInfo_ = outputDeviceInfo;
529 castHandleInfo.avRouterListener_ = std::make_shared<AVRouterListenerMock>();
530 g_AVRouterImpl->castHandleToInfoMap_.insert({castHandle, castHandleInfo});
531
532 int32_t castState = 12;
533 g_AVRouterImpl->OnCastStateChange(castState, deviceInfo);
534
535 EXPECT_TRUE(g_AVRouterImpl->IsInMirrorToStreamState() == false);
536 SLOGI("OnCastStateChange005 end");
537 }
538
539 /**
540 * @tc.name: OnCastEventRecv001
541 * @tc.desc: listener is nullptr
542 * @tc.type: FUNC
543 * @tc.require: NA
544 */
545 static HWTEST_F(AVRouterImplTest, OnCastEventRecv001, TestSize.Level0)
546 {
547 SLOGI("OnCastEventRecv001 begin");
548 OutputDeviceInfo outputDeviceInfo;
549 DeviceInfo deviceInfo;
550 deviceInfo.providerId_ = 1;
551 outputDeviceInfo.deviceInfos_.push_back(deviceInfo);
552
553 int64_t castHandle = 2000;
554 AVRouter::CastHandleInfo castHandleInfo;
555 castHandleInfo.outputDeviceInfo_ = outputDeviceInfo;
556 g_AVRouterImpl->castHandleToInfoMap_.insert({castHandle, castHandleInfo});
557
558 int32_t errorCode = -1;
559 std::string errorMsg = "**";
560 g_AVRouterImpl->OnCastEventRecv(errorCode, errorMsg);
561
562 EXPECT_TRUE(castHandleInfo.avRouterListener_ == nullptr);
563 SLOGI("OnCastEventRecv001 end");
564 }
565
566 /**
567 * @tc.name: OnCastEventRecv002
568 * @tc.desc: listener is nullptr
569 * @tc.type: FUNC
570 * @tc.require: NA
571 */
572 static HWTEST_F(AVRouterImplTest, OnCastEventRecv002, TestSize.Level0)
573 {
574 SLOGI("OnCastEventRecv002 begin");
575 OutputDeviceInfo outputDeviceInfo;
576 DeviceInfo deviceInfo;
577 deviceInfo.providerId_ = 1;
578 outputDeviceInfo.deviceInfos_.push_back(deviceInfo);
579
580 int64_t castHandle = 2000;
581 AVRouter::CastHandleInfo castHandleInfo;
582 castHandleInfo.outputDeviceInfo_ = outputDeviceInfo;
583 castHandleInfo.avRouterListener_ = std::make_shared<AVRouterListenerMock>();
584 g_AVRouterImpl->castHandleToInfoMap_.insert({castHandle, castHandleInfo});
585
586 int32_t errorCode = -1;
587 std::string errorMsg = "**";
588 g_AVRouterImpl->OnCastEventRecv(errorCode, errorMsg);
589
590 EXPECT_TRUE(castHandleInfo.avRouterListener_ != nullptr);
591 SLOGI("OnCastEventRecv002 end");
592 }
593
594 /**
595 * @tc.name: DisconnectOtherSession001
596 * @tc.desc: listener is nullptr
597 * @tc.type: FUNC
598 * @tc.require: NA
599 */
600 static HWTEST_F(AVRouterImplTest, DisconnectOtherSession001, TestSize.Level0)
601 {
602 SLOGI("DisconnectOtherSession001 begin");
603 DeviceInfo deviceInfo;
604 deviceInfo.providerId_ = 1;
605
606 std::string sessionId = "12345";
607 std::shared_ptr<IAVRouterListener> listener = std::make_shared<AVRouterListenerMock>();
608 g_AVRouterImpl->mirrorSessionMap_.insert({sessionId, listener});
609
610 g_AVRouterImpl->DisconnectOtherSession(sessionId, deviceInfo);
611 EXPECT_TRUE(listener != nullptr);
612 SLOGI("DisconnectOtherSession001 end");
613 }
614
615 /**
616 * @tc.name: DisconnectOtherSession002
617 * @tc.desc: listener is nullptr
618 * @tc.type: FUNC
619 * @tc.require: NA
620 */
621 static HWTEST_F(AVRouterImplTest, DisconnectOtherSession002, TestSize.Level0)
622 {
623 SLOGI("DisconnectOtherSession002 begin");
624 DeviceInfo deviceInfo;
625 deviceInfo.providerId_ = 1;
626
627 std::string sessionId = "12345";
628 std::shared_ptr<IAVRouterListener> listener = nullptr;
629 g_AVRouterImpl->mirrorSessionMap_.insert({"12344", listener});
630
631 g_AVRouterImpl->DisconnectOtherSession(sessionId, deviceInfo);
632 EXPECT_TRUE(listener == nullptr);
633 SLOGI("DisconnectOtherSession002 end");
634 }
635
636 /**
637 * @tc.name: DisconnectOtherSession003
638 * @tc.desc: listener is nullptr
639 * @tc.type: FUNC
640 * @tc.require: NA
641 */
642 static HWTEST_F(AVRouterImplTest, DisconnectOtherSession003, TestSize.Level0)
643 {
644 SLOGI("DisconnectOtherSession003 begin");
645 OutputDeviceInfo outputDeviceInfo;
646 DeviceInfo deviceInfo;
647 deviceInfo.providerId_ = 1;
648 outputDeviceInfo.deviceInfos_.push_back(deviceInfo);
649
650 int64_t castHandle = 2000;
651 AVRouter::CastHandleInfo castHandleInfo;
652 castHandleInfo.sessionId_ = "12345";
653 castHandleInfo.outputDeviceInfo_ = outputDeviceInfo;
654 castHandleInfo.avRouterListener_ = std::make_shared<AVRouterListenerMock>();
655 g_AVRouterImpl->castHandleToInfoMap_.insert({castHandle, castHandleInfo});
656
657 std::string sessionId = "12345";
658 g_AVRouterImpl->DisconnectOtherSession(sessionId, deviceInfo);
659 EXPECT_TRUE(castHandleInfo.avRouterListener_ != nullptr);
660 SLOGI("DisconnectOtherSession003 end");
661 }
662
663 /**
664 * @tc.name: DisconnectOtherSession004
665 * @tc.desc: listener is nullptr
666 * @tc.type: FUNC
667 * @tc.require: NA
668 */
669 static HWTEST_F(AVRouterImplTest, DisconnectOtherSession004, TestSize.Level0)
670 {
671 SLOGI("DisconnectOtherSession004 begin");
672 OutputDeviceInfo outputDeviceInfo;
673 DeviceInfo deviceInfo;
674 deviceInfo.providerId_ = 1;
675 outputDeviceInfo.deviceInfos_.push_back(deviceInfo);
676
677 int64_t castHandle = 2000;
678 AVRouter::CastHandleInfo castHandleInfo;
679 castHandleInfo.sessionId_ = "12345";
680 castHandleInfo.outputDeviceInfo_ = outputDeviceInfo;
681 castHandleInfo.avRouterListener_ = std::make_shared<AVRouterListenerMock>();
682 g_AVRouterImpl->castHandleToInfoMap_.insert({castHandle, castHandleInfo});
683
684 std::string sessionId = "12340";
685 g_AVRouterImpl->DisconnectOtherSession(sessionId, deviceInfo);
686 EXPECT_TRUE(castHandleInfo.avRouterListener_ != nullptr);
687 SLOGI("DisconnectOtherSession004 end");
688 }
689
690 /**
691 * @tc.name: DisconnectOtherSession005
692 * @tc.desc: listener is nullptr
693 * @tc.type: FUNC
694 * @tc.require: NA
695 */
696 static HWTEST_F(AVRouterImplTest, DisconnectOtherSession005, TestSize.Level0)
697 {
698 SLOGI("DisconnectOtherSession005 begin");
699 OutputDeviceInfo outputDeviceInfo;
700 DeviceInfo deviceInfo;
701 deviceInfo.providerId_ = 1;
702 outputDeviceInfo.deviceInfos_.push_back(deviceInfo);
703
704 int64_t castHandle = 2000;
705 AVRouter::CastHandleInfo castHandleInfo;
706 castHandleInfo.sessionId_ = "12345";
707 castHandleInfo.outputDeviceInfo_ = outputDeviceInfo;
708 castHandleInfo.avRouterListener_ = nullptr;
709 g_AVRouterImpl->castHandleToInfoMap_.insert({castHandle, castHandleInfo});
710
711 std::string sessionId = "12340";
712 g_AVRouterImpl->DisconnectOtherSession(sessionId, deviceInfo);
713 EXPECT_TRUE(castHandleInfo.avRouterListener_ == nullptr);
714 SLOGI("DisconnectOtherSession005 end");
715 }
716
717 /**
718 * @tc.name: StartDeviceLogging001
719 * @tc.desc: the size of providerManagerMap_ bigger than zero
720 * @tc.type: FUNC
721 * @tc.require: NA
722 */
723 static HWTEST_F(AVRouterImplTest, StartDeviceLogging001, TestSize.Level0)
724 {
725 SLOGI("StartDeviceLogging001 begin");
726 int32_t fd = 0;
727 uint32_t maxSize = 0;
728 auto avCastProviderManager = std::make_shared<AVCastProviderManager>();
729 g_AVRouterImpl->providerManagerMap_.insert({fd, avCastProviderManager});
730 g_AVRouterImpl->StartDeviceLogging(fd, maxSize);
731 EXPECT_TRUE(!g_AVRouterImpl->providerManagerMap_.empty());
732 SLOGI("StartDeviceLogging001 end");
733 }
734
735 /**
736 * @tc.name: StopDeviceLogging001
737 * @tc.desc: set cacheStartDeviceLogging_ to false
738 * @tc.type: FUNC
739 * @tc.require: NA
740 */
741 static HWTEST_F(AVRouterImplTest, StopDeviceLogging001, TestSize.Level0)
742 {
743 SLOGI("StopDeviceLogging001 begin");
744 g_AVRouterImpl->cacheStartDeviceLogging_ = false;
745 g_AVRouterImpl->StopDeviceLogging();
746 EXPECT_TRUE(g_AVRouterImpl->cacheStartDeviceLogging_ == false);
747 SLOGI("StopDeviceLogging001 end");
748 }
749
750 /**
751 * @tc.name: StartCastDiscovery001
752 * @tc.desc: the size of providerManagerMap_ bigger than zero
753 * @tc.type: FUNC
754 * @tc.require: NA
755 */
756 static HWTEST_F(AVRouterImplTest, StartCastDiscovery001, TestSize.Level0)
757 {
758 SLOGI("StartCastDiscovery001 begin");
759 int32_t castDeviceCapability = 0;
760 std::vector<std::string> drmSchemes = {"test"};
761 auto avCastProviderManager = std::make_shared<AVCastProviderManager>();
762 g_AVRouterImpl->providerManagerMap_.insert({castDeviceCapability, avCastProviderManager});
763 g_AVRouterImpl->StartCastDiscovery(castDeviceCapability, drmSchemes);
764 EXPECT_TRUE(!g_AVRouterImpl->providerManagerMap_.empty());
765 SLOGI("StartCastDiscovery001 end");
766 }
767
768 /**
769 * @tc.name: StopCastDiscovery001
770 * @tc.desc: set cacheStartDeviceLogging_ to false
771 * @tc.type: FUNC
772 * @tc.require: NA
773 */
774 static HWTEST_F(AVRouterImplTest, StopCastDiscovery001, TestSize.Level0)
775 {
776 SLOGI("StopCastDiscovery001 begin");
777 g_AVRouterImpl->cacheStartDeviceLogging_ = false;
778 g_AVRouterImpl->StopCastDiscovery();
779 EXPECT_TRUE(g_AVRouterImpl->cacheStartDeviceLogging_ == false);
780 SLOGI("StopCastDiscovery001 end");
781 }
782
783 /**
784 * @tc.name: IsStopCastDiscovery001
785 * @tc.desc: judge excute of StopCastDiscovery
786 * @tc.type: FUNC
787 * @tc.require: NA
788 */
789 static HWTEST_F(AVRouterImplTest, IsStopCastDiscovery001, TestSize.Level0)
790 {
791 SLOGI("IsStopCastDiscovery001 begin");
792 g_AVRouterImpl->StopCastDiscovery();
793 auto pid = getpid();
794 EXPECT_TRUE(g_AVRouterImpl->IsStopCastDiscovery(pid) == false);
795
796 int32_t castDeviceCapability = 0;
797 std::vector<std::string> drmSchemes = {"test"};
798 g_AVRouterImpl->StartCastDiscovery(castDeviceCapability, drmSchemes);
799
800 EXPECT_TRUE(g_AVRouterImpl->IsStopCastDiscovery(100) == false);
801 EXPECT_TRUE(g_AVRouterImpl->IsStopCastDiscovery(pid) == true);
802 SLOGI("IsStopCastDiscovery001 end");
803 }
804
805 /**
806 * @tc.name: OnDeviceAvailable001
807 * @tc.desc: set servicePtr_ to not nullptr
808 * @tc.type: FUNC
809 * @tc.require: NA
810 */
811 static HWTEST_F(AVRouterImplTest, OnDeviceAvailable001, TestSize.Level0)
812 {
813 SLOGI("OnDeviceAvailable001 begin");
814 OutputDeviceInfo outputDeviceInfo;
815 DeviceInfo deviceInfo;
816 deviceInfo.providerId_ = 1;
817 outputDeviceInfo.deviceInfos_.push_back(deviceInfo);
818 auto listener = std::make_shared<AVSessionServiceListenerMock>();
819 g_AVRouterImpl->servicePtr_ = listener.get();
820 g_AVRouterImpl->OnDeviceAvailable(outputDeviceInfo);
821 EXPECT_TRUE(g_AVRouterImpl->servicePtr_ != nullptr);
822 SLOGI("OnDeviceAvailable001 end");
823 }
824
825 /**
826 * @tc.name: OnCastServerDied001
827 * @tc.desc: set servicePtr_ to not nullptr
828 * @tc.type: FUNC
829 * @tc.require: NA
830 */
831 static HWTEST_F(AVRouterImplTest, OnCastServerDied001, TestSize.Level0)
832 {
833 SLOGI("OnCastServerDied001 begin");
834 int32_t providerNumber = 0;
835 auto listener = std::make_shared<AVSessionServiceListenerMock>();
836 g_AVRouterImpl->servicePtr_ = listener.get();
837 g_AVRouterImpl->OnCastServerDied(providerNumber);
838 EXPECT_TRUE(g_AVRouterImpl->servicePtr_ != nullptr);
839 SLOGI("OnCastServerDied001 end");
840 }
841
842 /**
843 * @tc.name: GetRemoteController003
844 * @tc.desc: fail to get controller by handle
845 * @tc.type: FUNC
846 * @tc.require: NA
847 */
848 static HWTEST_F(AVRouterImplTest, GetRemoteController003, TestSize.Level0)
849 {
850 SLOGI("GetRemoteController003 begin");
851 g_AVRouterImpl->providerNumber_ = 1;
852 int32_t providerNumber = g_AVRouterImpl->providerNumber_;
853 int32_t castId = 1;
854 int64_t castHandle = static_cast<int64_t>((static_cast<uint64_t>(providerNumber) << 32) |
855 static_cast<uint32_t>(castId));
856
857 auto avCastProviderManager = std::make_shared<AVCastProviderManager>();
858 g_AVRouterImpl->providerManagerMap_[providerNumber] = avCastProviderManager;
859
860 int64_t handle = 2000;
861 AVRouter::CastHandleInfo castHandleInfo;
862 castHandleInfo.sessionId_ = "12345";
863 castHandleInfo.avRouterListener_ = std::make_shared<AVRouterListenerMock>();
864 g_AVRouterImpl->castHandleToInfoMap_[handle] = castHandleInfo;
865
866 auto controller = g_AVRouterImpl->GetRemoteController(castHandle);
867 EXPECT_TRUE(controller == nullptr);
868 SLOGI("GetRemoteController003 end");
869 }
870
871 /**
872 * @tc.name: GetRemoteController004
873 * @tc.desc: fail to get controller by handle
874 * @tc.type: FUNC
875 * @tc.require: NA
876 */
877 static HWTEST_F(AVRouterImplTest, GetRemoteController004, TestSize.Level0)
878 {
879 SLOGI("GetRemoteController004 begin");
880 g_AVRouterImpl->providerNumber_ = 1;
881 int32_t providerNumber = g_AVRouterImpl->providerNumber_;
882 int32_t castId = 1;
883 int64_t castHandle = static_cast<int64_t>((static_cast<uint64_t>(providerNumber) << 32) |
884 static_cast<uint32_t>(castId));
885
886 auto avCastProviderManager = std::make_shared<AVCastProviderManager>();
887 g_AVRouterImpl->providerManagerMap_[providerNumber] = avCastProviderManager;
888
889 AVRouter::CastHandleInfo castHandleInfo;
890 castHandleInfo.sessionId_ = "12345";
891 castHandleInfo.avRouterListener_ = std::make_shared<AVRouterListenerMock>();
892 g_AVRouterImpl->castHandleToInfoMap_[castHandle] = castHandleInfo;
893
894 auto controller = g_AVRouterImpl->GetRemoteController(castHandle);
895 EXPECT_TRUE(controller == nullptr);
896 SLOGI("GetRemoteController004 end");
897 }
898
899 /**
900 * @tc.name: StartCast004
901 * @tc.desc: the size of providerManagerMap_ bigger than zero
902 * @tc.type: FUNC
903 * @tc.require: NA
904 */
905 static HWTEST_F(AVRouterImplTest, StartCast004, TestSize.Level0)
906 {
907 SLOGI("StartCast004 begin");
908 g_AVRouterImpl->providerNumber_ = 1;
909 int32_t providerNumber = g_AVRouterImpl->providerNumber_;
910
911 OutputDeviceInfo outputDeviceInfo;
912 DeviceInfo deviceInfo;
913 deviceInfo.providerId_ = providerNumber;
914 outputDeviceInfo.deviceInfos_.push_back(deviceInfo);
915
916 auto avCastProviderManager = std::make_shared<AVCastProviderManager>();
917 auto hwCastProvider = std::make_shared<HwCastProvider>();
918 avCastProviderManager->Init(providerNumber, hwCastProvider);
919 g_AVRouterImpl->providerManagerMap_[providerNumber] = avCastProviderManager;
920
921 std::pair<std::string, std::string> serviceNameStatePair;
922 std::string sessionId = "1000";
923 AVRouter::CastHandleInfo castHandleInfo;
924 castHandleInfo.outputDeviceInfo_ = outputDeviceInfo;
925 castHandleInfo.sessionId_ = sessionId;
926 g_AVRouterImpl->castHandleToInfoMap_[providerNumber] = castHandleInfo;
927
928 auto ret = g_AVRouterImpl->StartCast(outputDeviceInfo, serviceNameStatePair, "1001");
929 EXPECT_TRUE(ret != AVSESSION_ERROR);
930 SLOGI("StartCast004 end");
931 }
932
933 /**
934 * @tc.name: StartCast005
935 * @tc.desc: the size of providerManagerMap_ bigger than zero
936 * @tc.type: FUNC
937 * @tc.require: NA
938 */
939 static HWTEST_F(AVRouterImplTest, StartCast005, TestSize.Level0)
940 {
941 SLOGI("StartCast005 begin");
942 g_AVRouterImpl->providerNumber_ = 1;
943 int32_t providerNumber = g_AVRouterImpl->providerNumber_;
944
945 OutputDeviceInfo outputDeviceInfo;
946 DeviceInfo deviceInfo;
947 deviceInfo.providerId_ = providerNumber;
948 outputDeviceInfo.deviceInfos_.push_back(deviceInfo);
949
950 auto avCastProviderManager = std::make_shared<AVCastProviderManager>();
951 auto hwCastProvider = std::make_shared<HwCastProvider>();
952 avCastProviderManager->Init(providerNumber, hwCastProvider);
953 g_AVRouterImpl->providerManagerMap_[providerNumber] = avCastProviderManager;
954
955 std::pair<std::string, std::string> serviceNameStatePair;
956 std::string sessionId = "1000";
957 AVRouter::CastHandleInfo castHandleInfo;
958 castHandleInfo.outputDeviceInfo_ = outputDeviceInfo;
959 castHandleInfo.sessionId_ = sessionId;
960 g_AVRouterImpl->castHandleToInfoMap_[providerNumber] = castHandleInfo;
961
962 OutputDeviceInfo outputDeviceInfo2;
963 DeviceInfo deviceInfo2;
964 deviceInfo2.providerId_ = providerNumber + 100;
965 outputDeviceInfo2.deviceInfos_.push_back(deviceInfo2);
966
967 auto ret = g_AVRouterImpl->StartCast(outputDeviceInfo2, serviceNameStatePair, sessionId);
968 EXPECT_TRUE(ret == AVSESSION_ERROR);
969 SLOGI("StartCast005 end");
970 }
971
972 /**
973 * @tc.name: StartCast006
974 * @tc.desc: the size of providerManagerMap_ bigger than zero
975 * @tc.type: FUNC
976 * @tc.require: NA
977 */
978 static HWTEST_F(AVRouterImplTest, StartCast006, TestSize.Level0)
979 {
980 SLOGI("StartCast006 begin");
981 g_AVRouterImpl->providerNumber_ = 1;
982 int32_t providerNumber = g_AVRouterImpl->providerNumber_;
983
984 OutputDeviceInfo outputDeviceInfo;
985 DeviceInfo deviceInfo;
986 deviceInfo.providerId_ = providerNumber;
987 outputDeviceInfo.deviceInfos_.push_back(deviceInfo);
988
989 auto avCastProviderManager = std::make_shared<AVCastProviderManager>();
990 auto hwCastProvider = std::make_shared<HwCastProvider>();
991 avCastProviderManager->Init(providerNumber, hwCastProvider);
992 g_AVRouterImpl->providerManagerMap_[providerNumber] = avCastProviderManager;
993
994 std::pair<std::string, std::string> serviceNameStatePair;
995 std::string sessionId = "1000";
996 AVRouter::CastHandleInfo castHandleInfo;
997 castHandleInfo.outputDeviceInfo_ = outputDeviceInfo;
998 castHandleInfo.sessionId_ = sessionId;
999 g_AVRouterImpl->castHandleToInfoMap_[providerNumber] = castHandleInfo;
1000
1001 auto ret = g_AVRouterImpl->StartCast(outputDeviceInfo, serviceNameStatePair, sessionId);
1002 EXPECT_TRUE(ret == AVSESSION_ERROR);
1003 SLOGI("StartCast006 end");
1004 }
1005
1006 /**
1007 * @tc.name: AddDevice005
1008 * @tc.desc: success to add device
1009 * @tc.type: FUNC
1010 * @tc.require: NA
1011 */
1012 static HWTEST_F(AVRouterImplTest, AddDevice005, TestSize.Level0)
1013 {
1014 SLOGI("AddDevice005 begin");
1015 g_AVRouterImpl->providerNumber_ = 1;
1016 int32_t providerNumber = g_AVRouterImpl->providerNumber_;
1017
1018 OutputDeviceInfo outputDeviceInfo;
1019 DeviceInfo deviceInfo;
1020 deviceInfo.providerId_ = providerNumber;
1021 outputDeviceInfo.deviceInfos_.push_back(deviceInfo);
1022
1023 int32_t castId = 1;
1024 uint32_t spid = 33;
1025 int64_t castHandle = static_cast<int64_t>((static_cast<uint64_t>(providerNumber) << 32) |
1026 static_cast<uint32_t>(castId));
1027
1028 AVRouter::CastHandleInfo castHandleInfo;
1029 castHandleInfo.outputDeviceInfo_ = outputDeviceInfo;
1030 g_AVRouterImpl->castHandleToInfoMap_[castHandle] = castHandleInfo;
1031
1032 int32_t ret = g_AVRouterImpl->AddDevice(castId, outputDeviceInfo, spid);
1033 EXPECT_TRUE(ret == AVSESSION_SUCCESS);
1034 SLOGI("AddDevice005 end");
1035 }
1036
1037 /**
1038 * @tc.name: AddDevice006
1039 * @tc.desc: fail to add device
1040 * @tc.type: FUNC
1041 * @tc.require: NA
1042 */
1043 static HWTEST_F(AVRouterImplTest, AddDevice006, TestSize.Level0)
1044 {
1045 SLOGI("AddDevice006 begin");
1046 g_AVRouterImpl->providerNumber_ = 1;
1047 int32_t providerNumber = g_AVRouterImpl->providerNumber_;
1048
1049 OutputDeviceInfo outputDeviceInfo;
1050 DeviceInfo deviceInfo;
1051 deviceInfo.providerId_ = providerNumber;
1052 outputDeviceInfo.deviceInfos_.push_back(deviceInfo);
1053
1054 int32_t castId = 1;
1055 uint32_t spid = 33;
1056 int64_t castHandle = static_cast<int64_t>((static_cast<uint64_t>(providerNumber) << 32) |
1057 static_cast<uint32_t>(castId));
1058
1059 AVRouter::CastHandleInfo castHandleInfo;
1060 castHandleInfo.outputDeviceInfo_ = outputDeviceInfo;
1061 g_AVRouterImpl->castHandleToInfoMap_[castHandle] = castHandleInfo;
1062
1063 int32_t ret = g_AVRouterImpl->AddDevice(castId + 1, outputDeviceInfo, spid);
1064 EXPECT_TRUE(ret == ERR_DEVICE_CONNECTION_FAILED);
1065 SLOGI("AddDevice006 end");
1066 }
1067
1068 /**
1069 * @tc.name: StopCast001
1070 * @tc.desc: success to stop cast
1071 * @tc.type: FUNC
1072 * @tc.require: NA
1073 */
1074 static HWTEST_F(AVRouterImplTest, StopCast001, TestSize.Level0)
1075 {
1076 SLOGI("StopCast001 begin");
1077 bool continuePlay = true;
1078 g_AVRouterImpl->providerNumber_ = 1;
1079 int32_t providerNumber = g_AVRouterImpl->providerNumber_;
1080 int32_t castId = 1;
1081 int64_t castHandle = static_cast<int64_t>((static_cast<uint64_t>(providerNumber) << 32) |
1082 static_cast<uint32_t>(castId));
1083
1084 OutputDeviceInfo outputDeviceInfo;
1085 DeviceInfo deviceInfo;
1086 deviceInfo.providerId_ = providerNumber;
1087 outputDeviceInfo.deviceInfos_.push_back(deviceInfo);
1088
1089 auto avCastProviderManager = std::make_shared<AVCastProviderManager>();
1090 auto hwCastProvider = std::make_shared<HwCastProvider>();
1091 avCastProviderManager->Init(providerNumber, hwCastProvider);
1092 g_AVRouterImpl->providerManagerMap_[providerNumber] = avCastProviderManager;
1093
1094 std::string sessionId = "1000";
1095 AVRouter::CastHandleInfo castHandleInfo;
1096 castHandleInfo.outputDeviceInfo_ = outputDeviceInfo;
1097 castHandleInfo.sessionId_ = sessionId;
1098 g_AVRouterImpl->castHandleToInfoMap_[providerNumber] = castHandleInfo;
1099
1100 auto ret = g_AVRouterImpl->StopCast(castHandle, continuePlay);
1101 EXPECT_TRUE(ret == AVSESSION_SUCCESS);
1102 SLOGI("StopCast001 end");
1103 }
1104
1105 /**
1106 * @tc.name: StopCastSession001
1107 * @tc.desc: success to stop cast session
1108 * @tc.type: FUNC
1109 * @tc.require: NA
1110 */
1111 static HWTEST_F(AVRouterImplTest, StopCastSession001, TestSize.Level0)
1112 {
1113 SLOGI("StopCastSession001 begin");
1114 g_AVRouterImpl->providerNumber_ = 1;
1115 int32_t providerNumber = g_AVRouterImpl->providerNumber_;
1116 int32_t castId = 1;
1117 int64_t castHandle = static_cast<int64_t>((static_cast<uint64_t>(providerNumber) << 32) |
1118 static_cast<uint32_t>(castId));
1119
1120 OutputDeviceInfo outputDeviceInfo;
1121 DeviceInfo deviceInfo;
1122 deviceInfo.providerId_ = providerNumber;
1123 outputDeviceInfo.deviceInfos_.push_back(deviceInfo);
1124
1125 auto avCastProviderManager = std::make_shared<AVCastProviderManager>();
1126 auto hwCastProvider = std::make_shared<HwCastProvider>();
1127 avCastProviderManager->Init(providerNumber, hwCastProvider);
1128 g_AVRouterImpl->providerManagerMap_[providerNumber] = avCastProviderManager;
1129
1130 AVRouter::CastHandleInfo castHandleInfo;
1131 castHandleInfo.outputDeviceInfo_ = outputDeviceInfo;
1132 g_AVRouterImpl->castHandleToInfoMap_[providerNumber] = castHandleInfo;
1133 g_AVRouterImpl->castHandleToInfoMap_[providerNumber + 100] = castHandleInfo;
1134
1135 auto ret = g_AVRouterImpl->StopCastSession(castHandle);
1136 EXPECT_TRUE(ret == AVSESSION_SUCCESS);
1137 SLOGI("StopCastSession001 end");
1138 }
1139
1140 /**
1141 * @tc.name: GetRemoteController005
1142 * @tc.desc: find controller in castHandleToInfoMap_
1143 * @tc.type: FUNC
1144 * @tc.require: NA
1145 */
1146 static HWTEST_F(AVRouterImplTest, GetRemoteController005, TestSize.Level0)
1147 {
1148 SLOGI("GetRemoteController005 begin");
1149 int32_t providerNumber = 1;
1150 int32_t castId = 1;
1151 g_AVRouterImpl->providerNumber_ = 1;
1152 int64_t castHandle = static_cast<int64_t>((static_cast<uint64_t>(providerNumber) << 32) |
1153 static_cast<uint32_t>(castId));
1154
1155 auto avCastProviderManager = std::make_shared<AVCastProviderManager>();
1156 auto hwCastProvider = std::make_shared<HwCastProvider>();
1157 avCastProviderManager->Init(providerNumber, hwCastProvider);
1158 g_AVRouterImpl->providerManagerMap_[providerNumber] = avCastProviderManager;
1159
1160 AVRouter::CastHandleInfo castHandleInfo;
1161 castHandleInfo.sessionId_ = "12345";
1162 castHandleInfo.avRouterListener_ = std::make_shared<AVRouterListenerMock>();
1163 AVRouter::CastHandleInfo castHandleInfo2;
1164 castHandleInfo2.sessionId_ = "12346";
1165 castHandleInfo2.avRouterListener_ = nullptr;
1166 g_AVRouterImpl->castHandleToInfoMap_[castHandle] = castHandleInfo;
1167 g_AVRouterImpl->castHandleToInfoMap_[castHandle + 1] = castHandleInfo2;
1168
1169 auto controller = g_AVRouterImpl->GetRemoteController(castHandle);
1170 EXPECT_TRUE(controller == nullptr);
1171 SLOGI("GetRemoteController005 end");
1172 }
1173
1174 /**
1175 * @tc.name: GetRemoteController006
1176 * @tc.desc: find controller in providerManagerMap_
1177 * @tc.type: FUNC
1178 * @tc.require: NA
1179 */
1180 static HWTEST_F(AVRouterImplTest, GetRemoteController006, TestSize.Level0)
1181 {
1182 SLOGI("GetRemoteController005 begin");
1183 int32_t providerNumber = 1;
1184 int32_t castId = 1;
1185 g_AVRouterImpl->providerNumber_ = 1;
1186 int64_t castHandle = static_cast<int64_t>((static_cast<uint64_t>(providerNumber) << 32) |
1187 static_cast<uint32_t>(castId));
1188
1189 auto avCastProviderManager = std::make_shared<AVCastProviderManager>();
1190 auto hwCastProvider = std::make_shared<HwCastProvider>();
1191 avCastProviderManager->Init(providerNumber, hwCastProvider);
1192 g_AVRouterImpl->providerManagerMap_[providerNumber] = avCastProviderManager;
1193
1194 AVRouter::CastHandleInfo castHandleInfo;
1195 castHandleInfo.sessionId_ = "12345";
1196 castHandleInfo.avRouterListener_ = nullptr;
1197 g_AVRouterImpl->castHandleToInfoMap_[castHandle] = castHandleInfo;
1198
1199 auto controller = g_AVRouterImpl->GetRemoteController(castHandle);
1200 EXPECT_TRUE(controller == nullptr);
1201 SLOGI("GetRemoteController006 end");
1202 }
1203
1204 /**
1205 * @tc.name: RegisterCallback001
1206 * @tc.desc: have no provider in castHandleToInfoMap_
1207 * @tc.type: FUNC
1208 * @tc.require: NA
1209 */
1210 static HWTEST_F(AVRouterImplTest, RegisterCallback001, TestSize.Level0)
1211 {
1212 SLOGI("RegisterCallback001 begin");
1213 int32_t providerNumber = 20;
1214 int32_t castId = 20;
1215 g_AVRouterImpl->providerNumber_ = providerNumber;
1216 int64_t castHandle = static_cast<int64_t>((static_cast<uint64_t>(providerNumber) << 32) |
1217 static_cast<uint32_t>(castId));
1218
1219 auto avCastProviderManager = std::make_shared<AVCastProviderManager>();
1220 auto hwCastProvider = std::make_shared<HwCastProvider>();
1221 avCastProviderManager->Init(providerNumber, hwCastProvider);
1222 g_AVRouterImpl->providerManagerMap_[providerNumber] = avCastProviderManager;
1223
1224 std::shared_ptr<IAVRouterListener> callback = std::make_shared<AVRouterListenerMock>();
1225 std::string sessionId = "12345";
1226 DeviceInfo deviceInfo;
1227 deviceInfo.providerId_ = providerNumber;
1228
1229 auto ret = g_AVRouterImpl->RegisterCallback(castHandle, callback, sessionId, deviceInfo);
1230 EXPECT_TRUE(AVSESSION_SUCCESS == ret);
1231 SLOGI("RegisterCallback001 end");
1232 }
1233
1234 /**
1235 * @tc.name: RegisterCallback002
1236 * @tc.desc: find controller in providerManagerMap_ but avRouterListener_ is null
1237 * @tc.type: FUNC
1238 * @tc.require: NA
1239 */
1240 static HWTEST_F(AVRouterImplTest, RegisterCallback002, TestSize.Level0)
1241 {
1242 SLOGI("RegisterCallback002 begin");
1243 int32_t providerNumber = 21;
1244 int32_t castId = 21;
1245 g_AVRouterImpl->providerNumber_ = providerNumber;
1246 int64_t castHandle = static_cast<int64_t>((static_cast<uint64_t>(providerNumber) << 32) |
1247 static_cast<uint32_t>(castId));
1248
1249 auto avCastProviderManager = std::make_shared<AVCastProviderManager>();
1250 auto hwCastProvider = std::make_shared<HwCastProvider>();
1251 avCastProviderManager->Init(providerNumber, hwCastProvider);
1252 g_AVRouterImpl->providerManagerMap_[providerNumber] = avCastProviderManager;
1253
1254 AVRouter::CastHandleInfo castHandleInfo;
1255 castHandleInfo.sessionId_ = "12345";
1256 castHandleInfo.avRouterListener_ = nullptr;
1257 g_AVRouterImpl->castHandleToInfoMap_[castHandle] = castHandleInfo;
1258
1259 std::shared_ptr<IAVRouterListener> callback = std::make_shared<AVRouterListenerMock>();
1260 std::string sessionId = "12345";
1261 DeviceInfo deviceInfo;
1262 deviceInfo.providerId_ = providerNumber;
1263
1264 auto ret = g_AVRouterImpl->RegisterCallback(castHandle, callback, sessionId, deviceInfo);
1265 EXPECT_TRUE(AVSESSION_SUCCESS == ret);
1266 SLOGI("RegisterCallback002 end");
1267 }
1268
1269 /**
1270 * @tc.name: RegisterCallback003
1271 * @tc.desc: find controller in providerManagerMap_ and avRouterListener_ is not null
1272 * @tc.type: FUNC
1273 * @tc.require: NA
1274 */
1275 static HWTEST_F(AVRouterImplTest, RegisterCallback003, TestSize.Level0)
1276 {
1277 SLOGI("RegisterCallback003 begin");
1278 int32_t providerNumber = 22;
1279 int32_t castId = 22;
1280 g_AVRouterImpl->providerNumber_ = providerNumber;
1281 int64_t castHandle = static_cast<int64_t>((static_cast<uint64_t>(providerNumber) << 32) |
1282 static_cast<uint32_t>(castId));
1283
1284 auto avCastProviderManager = std::make_shared<AVCastProviderManager>();
1285 auto hwCastProvider = std::make_shared<HwCastProvider>();
1286 avCastProviderManager->Init(providerNumber, hwCastProvider);
1287 g_AVRouterImpl->providerManagerMap_[providerNumber] = avCastProviderManager;
1288
1289 AVRouter::CastHandleInfo castHandleInfo;
1290 castHandleInfo.sessionId_ = "12345";
1291 castHandleInfo.avRouterListener_ = std::make_shared<AVRouterListenerMock>();
1292 g_AVRouterImpl->castHandleToInfoMap_[castHandle] = castHandleInfo;
1293
1294 std::shared_ptr<IAVRouterListener> callback = std::make_shared<AVRouterListenerMock>();
1295 std::string sessionId = "12345";
1296 DeviceInfo deviceInfo;
1297 deviceInfo.providerId_ = providerNumber;
1298
1299 auto ret = g_AVRouterImpl->RegisterCallback(castHandle, callback, sessionId, deviceInfo);
1300 EXPECT_TRUE(AVSESSION_SUCCESS == ret);
1301 SLOGI("RegisterCallback003 end");
1302 }
1303
1304 /**
1305 * @tc.name: UnRegisterCallback001
1306 * @tc.desc: find controller in providerManagerMap_
1307 * @tc.type: FUNC
1308 * @tc.require: NA
1309 */
1310 static HWTEST_F(AVRouterImplTest, UnRegisterCallback001, TestSize.Level0)
1311 {
1312 SLOGI("UnRegisterCallback001 begin");
1313 int32_t providerNumber = 30;
1314 int32_t castId = 30;
1315 g_AVRouterImpl->providerNumber_ = providerNumber;
1316 int64_t castHandle = static_cast<int64_t>((static_cast<uint64_t>(providerNumber) << 32) |
1317 static_cast<uint32_t>(castId));
1318
1319 auto avCastProviderManager = std::make_shared<AVCastProviderManager>();
1320 auto hwCastProvider = std::make_shared<HwCastProvider>();
1321 avCastProviderManager->Init(providerNumber, hwCastProvider);
1322 g_AVRouterImpl->providerManagerMap_[providerNumber] = avCastProviderManager;
1323
1324 std::string sessionId = "12345";
1325 auto listener = std::make_shared<AVRouterListenerMock>();
1326 AVRouter::CastHandleInfo castHandleInfo;
1327 castHandleInfo.sessionId_ = sessionId;
1328 castHandleInfo.avRouterListener_ = listener;
1329
1330 AVRouter::CastHandleInfo castHandleInfo2;
1331 castHandleInfo2.sessionId_ = "12346";
1332 castHandleInfo2.avRouterListener_ = listener;
1333
1334 g_AVRouterImpl->castHandleToInfoMap_[castHandle] = castHandleInfo;
1335 g_AVRouterImpl->castHandleToInfoMap_[castHandle + 1] = castHandleInfo2;
1336 g_AVRouterImpl->mirrorSessionMap_[sessionId] = listener;
1337
1338 std::shared_ptr<IAVRouterListener> callback = std::make_shared<AVRouterListenerMock>();
1339 auto ret = g_AVRouterImpl->UnRegisterCallback(castHandle, callback, sessionId);
1340 EXPECT_TRUE(AVSESSION_SUCCESS == ret);
1341 SLOGI("UnRegisterCallback001 end");
1342 }
1343
1344 /**
1345 * @tc.name: UnRegisterCallback002
1346 * @tc.desc: find controller in providerManagerMap_
1347 * @tc.type: FUNC
1348 * @tc.require: NA
1349 */
1350 static HWTEST_F(AVRouterImplTest, UnRegisterCallback002, TestSize.Level0)
1351 {
1352 SLOGI("UnRegisterCallback002 begin");
1353 int32_t providerNumber = 31;
1354 int32_t castId = 31;
1355 g_AVRouterImpl->providerNumber_ = providerNumber;
1356 int64_t castHandle = static_cast<int64_t>((static_cast<uint64_t>(providerNumber) << 32) |
1357 static_cast<uint32_t>(castId));
1358
1359 auto avCastProviderManager = std::make_shared<AVCastProviderManager>();
1360 auto hwCastProvider = std::make_shared<HwCastProvider>();
1361 avCastProviderManager->Init(providerNumber, hwCastProvider);
1362 g_AVRouterImpl->providerManagerMap_[providerNumber] = avCastProviderManager;
1363
1364 std::string sessionId = "12345";
1365 auto listener = std::make_shared<AVRouterListenerMock>();
1366 AVRouter::CastHandleInfo castHandleInfo;
1367 castHandleInfo.sessionId_ = "12346";
1368 castHandleInfo.avRouterListener_ = listener;
1369
1370 AVRouter::CastHandleInfo castHandleInfo2;
1371 castHandleInfo2.sessionId_ = "12345";
1372 castHandleInfo2.avRouterListener_ = listener;
1373
1374 g_AVRouterImpl->castHandleToInfoMap_[castHandle] = castHandleInfo;
1375 g_AVRouterImpl->castHandleToInfoMap_[castHandle + 1] = castHandleInfo2;
1376 g_AVRouterImpl->mirrorSessionMap_[sessionId] = listener;
1377
1378 std::shared_ptr<IAVRouterListener> callback = std::make_shared<AVRouterListenerMock>();
1379 auto ret = g_AVRouterImpl->UnRegisterCallback(castHandle, callback, sessionId);
1380 EXPECT_TRUE(AVSESSION_SUCCESS == ret);
1381 SLOGI("UnRegisterCallback002 end");
1382 }
1383 /**
1384 * @tc.name: Release001
1385 * @tc.desc: call Release
1386 * @tc.type: FUNC
1387 * @tc.require: NA
1388 */
1389 static HWTEST_F(AVRouterImplTest, Release001, TestSize.Level0)
1390 {
1391 std::shared_ptr<AVRouterImpl> aVRouterImpl = std::make_shared<AVRouterImplMock>();
1392 auto ret = aVRouterImpl->Release();
1393 EXPECT_EQ(ret, false);
1394 }
1395
1396 /**
1397 * @tc.name: GetRemoteController007
1398 * @tc.desc: find controller in providerManagerMap_
1399 * @tc.type: FUNC
1400 * @tc.require: NA
1401 */
1402 static HWTEST_F(AVRouterImplTest, GetRemoteController007, TestSize.Level0)
1403 {
1404 SLOGI("GetRemoteController007 begin");
1405 int32_t providerNumber = 1;
1406 int32_t castId = 1;
1407 g_AVRouterImpl->providerNumber_ = 1;
1408 int64_t castHandle = static_cast<int64_t>((static_cast<uint64_t>(providerNumber) << 32) |
1409 static_cast<uint32_t>(castId));
1410
1411 auto avCastProviderManager = std::make_shared<AVCastProviderManager>();
1412 auto hwCastProvider = std::make_shared<HwCastProvider>();
1413 avCastProviderManager->Init(providerNumber, hwCastProvider);
1414 g_AVRouterImpl->providerManagerMap_[providerNumber] = avCastProviderManager;
1415
1416 AVRouter::CastHandleInfo castHandleInfo;
1417 castHandleInfo.sessionId_ = "12345";
1418 castHandleInfo.avRouterListener_ = nullptr;
1419 castHandleInfo.avCastControllerProxy_ = std::make_shared<AVCastControllerProxyMock>();
1420 g_AVRouterImpl->castHandleToInfoMap_[castHandle] = castHandleInfo;
1421
1422 auto controller = g_AVRouterImpl->GetRemoteController(castHandle);
1423 EXPECT_NE(controller, nullptr);
1424 SLOGI("GetRemoteController007 end");
1425 }
1426
1427 /**
1428 * @tc.name: GetRemoteController008
1429 * @tc.desc: find controller in providerManagerMap_
1430 * @tc.type: FUNC
1431 * @tc.require: NA
1432 */
1433 static HWTEST_F(AVRouterImplTest, GetRemoteController008, TestSize.Level0)
1434 {
1435 SLOGI("GetRemoteController008 begin");
1436 int32_t providerNumber = 1;
1437 int32_t castId = 1;
1438 g_AVRouterImpl->providerNumber_ = 1;
1439 int64_t castHandle = static_cast<int64_t>((static_cast<uint64_t>(providerNumber) << 32) |
1440 static_cast<uint32_t>(castId));
1441
1442 auto avCastProviderManager = std::make_shared<AVCastProviderManager>();
1443 auto hwCastProvider = std::make_shared<HwCastProvider>();
1444 avCastProviderManager->Init(providerNumber, hwCastProvider);
1445 g_AVRouterImpl->providerManagerMap_[providerNumber] = avCastProviderManager;
1446
1447 AVRouter::CastHandleInfo castHandleInfo;
1448 castHandleInfo.sessionId_ = "12345";
1449 castHandleInfo.avRouterListener_ = nullptr;
1450 g_AVRouterImpl->castHandleToInfoMap_.clear();
1451
1452 auto controller = g_AVRouterImpl->GetRemoteController(castHandle);
1453 EXPECT_EQ(controller, nullptr);
1454 SLOGI("GetRemoteController008 end");
1455 }
1456
1457 /**
1458 * @tc.name: DisconnectOtherSession006
1459 * @tc.desc: listener is nullptr
1460 * @tc.type: FUNC
1461 * @tc.require: NA
1462 */
1463 static HWTEST_F(AVRouterImplTest, DisconnectOtherSession006, TestSize.Level0)
1464 {
1465 SLOGI("DisconnectOtherSession006 begin");
1466 DeviceInfo deviceInfo;
1467 deviceInfo.providerId_ = 1;
1468
1469 std::string sessionId = "12345";
1470 std::shared_ptr<IAVRouterListener> listener = std::make_shared<AVRouterListenerMock>();
1471 ASSERT_TRUE(listener != nullptr);
1472 g_AVRouterImpl->mirrorSessionMap_.insert({sessionId, listener});
1473 g_AVRouterImpl->mirrorSessionMap_.insert({"other_id", listener});
1474
1475 g_AVRouterImpl->DisconnectOtherSession(sessionId, deviceInfo);
1476 EXPECT_TRUE(listener != nullptr);
1477 SLOGI("DisconnectOtherSession006 end");
1478 }
1479
1480 /**
1481 * @tc.name: OnDeviceStateChange001
1482 * @tc.desc: set servicePtr_ to not nullptr
1483 * @tc.type: FUNC
1484 * @tc.require: NA
1485 */
1486 static HWTEST_F(AVRouterImplTest, OnDeviceStateChange001, TestSize.Level0)
1487 {
1488 SLOGI("OnDeviceStateChange001 begin");
1489 ASSERT_TRUE(g_AVRouterImpl != nullptr);
1490 DeviceState deviceState;
1491 auto listener = std::make_shared<AVSessionServiceListenerMock>();
1492 ASSERT_TRUE(listener != nullptr);
1493 g_AVRouterImpl->servicePtr_ = listener.get();
1494 g_AVRouterImpl->OnDeviceStateChange(deviceState);
1495 EXPECT_TRUE(g_AVRouterImpl->servicePtr_ != nullptr);
1496 SLOGI("OnDeviceStateChange001 end");
1497 }
1498 } //AVSession
1499 } //OHOS