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 AVRouterImplTest : public testing::Test {
37 public:
38 static void SetUpTestCase();
39 static void TearDownTestCase();
40 void SetUp() override;
41 void TearDown() override;
42 };
43
SetUpTestCase()44 void AVRouterImplTest::SetUpTestCase()
45 {
46 SLOGI("set up AVSessionServiceTest");
47 system("killall -9 com.example.hiMusicDemo");
48 g_AVSessionService = std::make_shared<AVSessionService>(OHOS::AVSESSION_SERVICE_ID);
49 g_AVRouterImpl = std::make_shared<AVRouterImplMock>();
50 g_AVRouterImpl->Init(g_AVSessionService.get());
51 }
52
TearDownTestCase()53 void AVRouterImplTest::TearDownTestCase()
54 {
55 g_AVRouterImpl->Release();
56 g_AVSessionService->Close();
57 }
58
SetUp()59 void AVRouterImplTest::SetUp() {}
60
TearDown()61 void AVRouterImplTest::TearDown() {}
62
63 class AVRouterListenerMock : public IAVRouterListener {
64 public:
OnCastStateChange(int32_t castState,DeviceInfo deviceInfo,bool isNeedRemove)65 virtual void OnCastStateChange(int32_t castState, DeviceInfo deviceInfo, bool isNeedRemove) {}
66
OnCastEventRecv(int32_t errorCode,std::string & errorMsg)67 virtual void OnCastEventRecv(int32_t errorCode, std::string& errorMsg) {}
68
~AVRouterListenerMock()69 virtual ~AVRouterListenerMock() {}
70 };
71
72 class AVSessionServiceListenerMock : public IAVSessionServiceListener {
73 public:
74 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
ReleaseCastSession()75 void ReleaseCastSession() {}
CreateSessionByCast(const int64_t castHandle)76 void CreateSessionByCast(const int64_t castHandle) {}
NotifyDeviceAvailable(const OutputDeviceInfo & castOutputDeviceInfo)77 void NotifyDeviceAvailable(const OutputDeviceInfo& castOutputDeviceInfo) {}
NotifyDeviceLogEvent(const DeviceLogEventCode eventId,const int64_t param)78 void NotifyDeviceLogEvent(const DeviceLogEventCode eventId, const int64_t param) {}
NotifyDeviceOffline(const std::string & deviceId)79 void NotifyDeviceOffline(const std::string& deviceId) {}
setInCast(bool isInCast)80 void setInCast(bool isInCast) {}
SetIsSupportMirrorToStream(bool isSupportMirrorToStream)81 void SetIsSupportMirrorToStream(bool isSupportMirrorToStream) {}
82 #endif
~AVSessionServiceListenerMock()83 virtual ~AVSessionServiceListenerMock() {}
84 };
85
86 /**
87 * @tc.name: GetRemoteController001
88 * @tc.desc: get controller by handle
89 * @tc.type: FUNC
90 * @tc.require: NA
91 */
92 static HWTEST_F(AVRouterImplTest, GetRemoteController001, TestSize.Level1)
93 {
94 SLOGI("GetRemoteController001 begin");
95 int32_t num = g_AVRouterImpl->providerNumber_;
96 int64_t castHandle = static_cast<int64_t>((static_cast<uint64_t>(num) << 32) |
97 static_cast<uint32_t>(num));
98 auto controller = g_AVRouterImpl->GetRemoteController(castHandle);
99 EXPECT_TRUE(controller == nullptr);
100 SLOGI("GetRemoteController001 end");
101 }
102
103 /**
104 * @tc.name: GetRemoteController002
105 * @tc.desc: get controller by handle
106 * @tc.type: FUNC
107 * @tc.require: NA
108 */
109 static HWTEST_F(AVRouterImplTest, GetRemoteController002, TestSize.Level1)
110 {
111 SLOGI("GetRemoteController002 begin");
112 int32_t num = g_AVRouterImpl->providerNumber_;
113 g_AVRouterImpl->providerManagerMap_[num] = nullptr;
114 int64_t castHandle = static_cast<int64_t>((static_cast<uint64_t>(num) << 32) |
115 static_cast<uint32_t>(num));
116 auto controller = g_AVRouterImpl->GetRemoteController(castHandle);
117 EXPECT_TRUE(controller == nullptr);
118 SLOGI("GetRemoteController002 end");
119 }
120
121 /**
122 * @tc.name: StartCast001
123 * @tc.desc: sessinId have existed in castHandleToInfoMap_
124 * @tc.type: FUNC
125 * @tc.require: NA
126 */
127 static HWTEST_F(AVRouterImplTest, StartCast001, TestSize.Level1)
128 {
129 SLOGI("StartCast001 begin");
130 OutputDeviceInfo outputDeviceInfo;
131 DeviceInfo deviceInfo;
132 deviceInfo.providerId_ = g_AVRouterImpl->providerNumber_;
133 outputDeviceInfo.deviceInfos_.push_back(deviceInfo);
134 std::pair<std::string, std::string> serviceNameStatePair;
135 std::string sessionId = "1000";
136
137 int32_t number = 10;
138 AVRouter::CastHandleInfo castHandleInfo;
139 castHandleInfo.outputDeviceInfo_ = outputDeviceInfo;
140 castHandleInfo.sessionId_ = sessionId;
141 g_AVRouterImpl->castHandleToInfoMap_.insert({number, castHandleInfo});
142
143 auto ret = g_AVRouterImpl->StartCast(outputDeviceInfo, serviceNameStatePair, sessionId);
144 EXPECT_TRUE(ret == AVSESSION_ERROR);
145 SLOGI("StartCast001 end");
146 }
147
148 /**
149 * @tc.name: StartCast002
150 * @tc.desc: castHandleInfo.outputDeviceInfo_.deviceInfos_.size() equl to 0
151 * @tc.type: FUNC
152 * @tc.require: NA
153 */
154 static HWTEST_F(AVRouterImplTest, StartCast002, TestSize.Level1)
155 {
156 SLOGI("StartCast002 begin");
157 OutputDeviceInfo outputDeviceInfo;
158 DeviceInfo deviceInfo;
159 deviceInfo.providerId_ = g_AVRouterImpl->providerNumber_;
160 outputDeviceInfo.deviceInfos_.push_back(deviceInfo);
161 std::pair<std::string, std::string> serviceNameStatePair;
162 std::string sessionId = "1000";
163
164 AVRouter::CastHandleInfo castHandleInfo;
165 castHandleInfo.sessionId_ = "1001";
166 int32_t number = 11;
167 g_AVRouterImpl->castHandleToInfoMap_.insert({number, castHandleInfo});
168
169 auto ret = g_AVRouterImpl->StartCast(outputDeviceInfo, serviceNameStatePair, sessionId);
170 EXPECT_TRUE(ret == AVSESSION_ERROR);
171 SLOGI("StartCast002 end");
172 }
173
174 /**
175 * @tc.name: StartCast003
176 * @tc.desc: success to find deviceId in castHandleToInfoMap_
177 * @tc.type: FUNC
178 * @tc.require: NA
179 */
180 static HWTEST_F(AVRouterImplTest, StartCast003, TestSize.Level1)
181 {
182 SLOGI("StartCast003 begin");
183 OutputDeviceInfo outputDeviceInfo;
184 DeviceInfo deviceInfo;
185 deviceInfo.providerId_ = g_AVRouterImpl->providerNumber_;
186 outputDeviceInfo.deviceInfos_.push_back(deviceInfo);
187 std::pair<std::string, std::string> serviceNameStatePair;
188 std::string sessionId = "1000";
189
190 AVRouter::CastHandleInfo castHandleInfo;
191 castHandleInfo.sessionId_ = "1001";
192 castHandleInfo.outputDeviceInfo_ = outputDeviceInfo;
193 int32_t number = 11;
194 g_AVRouterImpl->castHandleToInfoMap_.insert({number, castHandleInfo});
195
196 auto ret = g_AVRouterImpl->StartCast(outputDeviceInfo, serviceNameStatePair, sessionId);
197 EXPECT_TRUE(ret == AVSESSION_ERROR);
198 SLOGI("StartCast003 end");
199 }
200
201 /**
202 * @tc.name: AddDevice001
203 * @tc.desc: success to add device
204 * @tc.type: FUNC
205 * @tc.require: NA
206 */
207 static HWTEST_F(AVRouterImplTest, AddDevice001, TestSize.Level1)
208 {
209 SLOGI("AddDevice001 begin");
210 int32_t tempId = g_AVRouterImpl->providerNumber_;
211 OutputDeviceInfo outputDeviceInfo;
212 DeviceInfo deviceInfo;
213 deviceInfo.providerId_ = tempId;
214 outputDeviceInfo.deviceInfos_.push_back(deviceInfo);
215
216 int32_t castId = 1;
217 int64_t castHandle = static_cast<int64_t>((static_cast<uint64_t>(tempId) << 32) |
218 static_cast<uint32_t>(castId));
219
220 AVRouter::CastHandleInfo castHandleInfo;
221 castHandleInfo.outputDeviceInfo_ = outputDeviceInfo;
222 g_AVRouterImpl->castHandleToInfoMap_.insert({castHandle, castHandleInfo});
223
224 int32_t ret = g_AVRouterImpl->AddDevice(castId, outputDeviceInfo);
225 EXPECT_TRUE(ret == AVSESSION_SUCCESS);
226 SLOGI("AddDevice001 end");
227 }
228
229 /**
230 * @tc.name: AddDevice002
231 * @tc.desc: fail to add device
232 * @tc.type: FUNC
233 * @tc.require: NA
234 */
235 static HWTEST_F(AVRouterImplTest, AddDevice002, TestSize.Level1)
236 {
237 SLOGI("AddDevice002 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 int64_t castHandle = static_cast<int64_t>((static_cast<uint64_t>(tempId) << 32) |
246 static_cast<uint32_t>(castId));
247
248 AVRouter::CastHandleInfo castHandleInfo;
249 castHandleInfo.outputDeviceInfo_ = outputDeviceInfo;
250 g_AVRouterImpl->castHandleToInfoMap_.insert({castHandle + 100, castHandleInfo});
251
252 int32_t ret = g_AVRouterImpl->AddDevice(castId, outputDeviceInfo);
253 EXPECT_TRUE(ret == AVSESSION_SUCCESS);
254 SLOGI("AddDevice002 end");
255 }
256
257 /**
258 * @tc.name: AddDevice003
259 * @tc.desc: fail to add device
260 * @tc.type: FUNC
261 * @tc.require: NA
262 */
263 static HWTEST_F(AVRouterImplTest, AddDevice003, TestSize.Level1)
264 {
265 SLOGI("AddDevice003 begin");
266 int32_t tempId = g_AVRouterImpl->providerNumber_;
267 OutputDeviceInfo outputDeviceInfo;
268 DeviceInfo deviceInfo;
269 deviceInfo.providerId_ = tempId;
270 outputDeviceInfo.deviceInfos_.push_back(deviceInfo);
271
272 int32_t castId = 1;
273 int64_t castHandle = static_cast<int64_t>((static_cast<uint64_t>(tempId) << 32) |
274 static_cast<uint32_t>(castId));
275
276 AVRouter::CastHandleInfo castHandleInfo;
277 g_AVRouterImpl->castHandleToInfoMap_.insert({castHandle, castHandleInfo});
278
279 int32_t ret = g_AVRouterImpl->AddDevice(castId, outputDeviceInfo);
280 EXPECT_TRUE(ret == AVSESSION_SUCCESS);
281 SLOGI("AddDevice003 end");
282 }
283
284 /**
285 * @tc.name: AddDevice004
286 * @tc.desc: fail to add device
287 * @tc.type: FUNC
288 * @tc.require: NA
289 */
290 static HWTEST_F(AVRouterImplTest, AddDevice004, TestSize.Level1)
291 {
292 SLOGI("AddDevice004 begin");
293 int32_t tempId = g_AVRouterImpl->providerNumber_;
294 OutputDeviceInfo outputDeviceInfo;
295 DeviceInfo deviceInfo;
296 deviceInfo.providerId_ = tempId;
297 outputDeviceInfo.deviceInfos_.push_back(deviceInfo);
298
299 int32_t castId = 1;
300 int64_t castHandle = static_cast<int64_t>((static_cast<uint64_t>(tempId) << 32) |
301 static_cast<uint32_t>(castId));
302
303 OutputDeviceInfo outputDeviceInfo2;
304 DeviceInfo deviceInfo2;
305 deviceInfo2.providerId_ = 12321;
306 outputDeviceInfo2.deviceInfos_.push_back(deviceInfo2);
307
308 AVRouter::CastHandleInfo castHandleInfo;
309 castHandleInfo.outputDeviceInfo_ = outputDeviceInfo2;
310 g_AVRouterImpl->castHandleToInfoMap_.insert({castHandle, castHandleInfo});
311
312 int32_t ret = g_AVRouterImpl->AddDevice(castId, outputDeviceInfo);
313 EXPECT_TRUE(ret == AVSESSION_SUCCESS);
314 SLOGI("AddDevice004 end");
315 }
316
317 /**
318 * @tc.name: SetServiceAllConnectState001
319 * @tc.desc: success to set connect state
320 * @tc.type: FUNC
321 * @tc.require: NA
322 */
323 static HWTEST_F(AVRouterImplTest, SetServiceAllConnectState001, TestSize.Level1)
324 {
325 SLOGI("SetServiceAllConnectState001 begin");
326 int32_t providerNumber = g_AVRouterImpl->providerNumber_;
327 int32_t castId = 1;
328 int64_t castHandle = static_cast<int64_t>((static_cast<uint64_t>(providerNumber) << 32) |
329 static_cast<uint32_t>(castId));
330
331 OutputDeviceInfo outputDeviceInfo;
332 DeviceInfo deviceInfo;
333 deviceInfo.providerId_ = providerNumber;
334 outputDeviceInfo.deviceInfos_.push_back(deviceInfo);
335
336 AVRouter::CastHandleInfo castHandleInfo;
337 castHandleInfo.outputDeviceInfo_ = outputDeviceInfo;
338 g_AVRouterImpl->castHandleToInfoMap_.insert({castHandle, castHandleInfo});
339
340 int32_t ret = g_AVRouterImpl->SetServiceAllConnectState(castId, deviceInfo);
341 EXPECT_TRUE(ret == AVSESSION_ERROR);
342 SLOGI("SetServiceAllConnectState001 end");
343 }
344
345 /**
346 * @tc.name: SetServiceAllConnectState002
347 * @tc.desc: fail to set connect state
348 * @tc.type: FUNC
349 * @tc.require: NA
350 */
351 static HWTEST_F(AVRouterImplTest, SetServiceAllConnectState002, TestSize.Level1)
352 {
353 SLOGI("SetServiceAllConnectState002 begin");
354 int32_t providerNumber = g_AVRouterImpl->providerNumber_;
355 int32_t castId = 1;
356 int64_t castHandle = static_cast<int64_t>((static_cast<uint64_t>(providerNumber) << 32) |
357 static_cast<uint32_t>(castId));
358
359 OutputDeviceInfo outputDeviceInfo;
360 DeviceInfo deviceInfo;
361 deviceInfo.providerId_ = providerNumber;
362 outputDeviceInfo.deviceInfos_.push_back(deviceInfo);
363
364 AVRouter::CastHandleInfo castHandleInfo;
365 castHandleInfo.outputDeviceInfo_ = outputDeviceInfo;
366 g_AVRouterImpl->castHandleToInfoMap_.insert({castHandle + 100, castHandleInfo});
367
368 int32_t ret = g_AVRouterImpl->SetServiceAllConnectState(castId, deviceInfo);
369 EXPECT_TRUE(ret == AVSESSION_ERROR);
370 SLOGI("SetServiceAllConnectState002 end");
371 }
372
373 /**
374 * @tc.name: OnCastStateChange001
375 * @tc.desc: set castState is disconnectStateFromCast_
376 * @tc.type: FUNC
377 * @tc.require: NA
378 */
379 static HWTEST_F(AVRouterImplTest, OnCastStateChange001, TestSize.Level1)
380 {
381 SLOGI("OnCastStateChange001 begin");
382 OutputDeviceInfo outputDeviceInfo;
383 DeviceInfo deviceInfo;
384 deviceInfo.providerId_ = 1;
385 outputDeviceInfo.deviceInfos_.push_back(deviceInfo);
386
387 int64_t castHandle = 2000;
388 AVRouter::CastHandleInfo castHandleInfo;
389 castHandleInfo.outputDeviceInfo_ = outputDeviceInfo;
390 castHandleInfo.avRouterListener_ = std::make_shared<AVRouterListenerMock>();
391 g_AVRouterImpl->castHandleToInfoMap_.insert({castHandle, castHandleInfo});
392
393 int32_t castState = g_AVRouterImpl->disconnectStateFromCast_;
394 g_AVRouterImpl->OnCastStateChange(castState, deviceInfo);
395
396 EXPECT_TRUE(castHandleInfo.avRouterListener_ != nullptr);
397 SLOGI("OnCastStateChange001 end");
398 }
399
400 /**
401 * @tc.name: OnCastStateChange002
402 * @tc.desc: set castState is connectStateFromCast_
403 * @tc.type: FUNC
404 * @tc.require: NA
405 */
406 static HWTEST_F(AVRouterImplTest, OnCastStateChange002, TestSize.Level1)
407 {
408 SLOGI("OnCastStateChange002 begin");
409 OutputDeviceInfo outputDeviceInfo;
410 DeviceInfo deviceInfo;
411 deviceInfo.providerId_ = 1;
412 outputDeviceInfo.deviceInfos_.push_back(deviceInfo);
413
414 int64_t castHandle = 2000;
415 AVRouter::CastHandleInfo castHandleInfo;
416 castHandleInfo.outputDeviceInfo_ = outputDeviceInfo;
417 castHandleInfo.avRouterListener_ = std::make_shared<AVRouterListenerMock>();
418 g_AVRouterImpl->castHandleToInfoMap_.insert({castHandle, castHandleInfo});
419
420 int32_t castState = g_AVRouterImpl->connectStateFromCast_;
421 g_AVRouterImpl->OnCastStateChange(castState, deviceInfo);
422
423 EXPECT_TRUE(castHandleInfo.avRouterListener_ != nullptr);
424 SLOGI("OnCastStateChange002 end");
425 }
426
427 /**
428 * @tc.name: OnCastStateChange003
429 * @tc.desc: listener is nullptr
430 * @tc.type: FUNC
431 * @tc.require: NA
432 */
433 static HWTEST_F(AVRouterImplTest, OnCastStateChange003, TestSize.Level1)
434 {
435 SLOGI("OnCastStateChange003 begin");
436 OutputDeviceInfo outputDeviceInfo;
437 DeviceInfo deviceInfo;
438 deviceInfo.providerId_ = 1;
439 outputDeviceInfo.deviceInfos_.push_back(deviceInfo);
440
441 int64_t castHandle = 2000;
442 AVRouter::CastHandleInfo castHandleInfo;
443 castHandleInfo.outputDeviceInfo_ = outputDeviceInfo;
444 g_AVRouterImpl->castHandleToInfoMap_.insert({castHandle, castHandleInfo});
445
446 int32_t castState = g_AVRouterImpl->connectStateFromCast_;
447 g_AVRouterImpl->OnCastStateChange(castState, deviceInfo);
448
449 EXPECT_TRUE(castHandleInfo.avRouterListener_ == nullptr);
450 SLOGI("OnCastStateChange003 end");
451 }
452
453 /**
454 * @tc.name: OnCastEventRecv001
455 * @tc.desc: listener is nullptr
456 * @tc.type: FUNC
457 * @tc.require: NA
458 */
459 static HWTEST_F(AVRouterImplTest, OnCastEventRecv001, TestSize.Level1)
460 {
461 SLOGI("OnCastEventRecv001 begin");
462 OutputDeviceInfo outputDeviceInfo;
463 DeviceInfo deviceInfo;
464 deviceInfo.providerId_ = 1;
465 outputDeviceInfo.deviceInfos_.push_back(deviceInfo);
466
467 int64_t castHandle = 2000;
468 AVRouter::CastHandleInfo castHandleInfo;
469 castHandleInfo.outputDeviceInfo_ = outputDeviceInfo;
470 g_AVRouterImpl->castHandleToInfoMap_.insert({castHandle, castHandleInfo});
471
472 int32_t errorCode = -1;
473 std::string errorMsg = "**";
474 g_AVRouterImpl->OnCastEventRecv(errorCode, errorMsg);
475
476 EXPECT_TRUE(castHandleInfo.avRouterListener_ == nullptr);
477 SLOGI("OnCastEventRecv001 end");
478 }
479
480 /**
481 * @tc.name: OnCastEventRecv002
482 * @tc.desc: listener is nullptr
483 * @tc.type: FUNC
484 * @tc.require: NA
485 */
486 static HWTEST_F(AVRouterImplTest, OnCastEventRecv002, TestSize.Level1)
487 {
488 SLOGI("OnCastEventRecv002 begin");
489 OutputDeviceInfo outputDeviceInfo;
490 DeviceInfo deviceInfo;
491 deviceInfo.providerId_ = 1;
492 outputDeviceInfo.deviceInfos_.push_back(deviceInfo);
493
494 int64_t castHandle = 2000;
495 AVRouter::CastHandleInfo castHandleInfo;
496 castHandleInfo.outputDeviceInfo_ = outputDeviceInfo;
497 castHandleInfo.avRouterListener_ = std::make_shared<AVRouterListenerMock>();
498 g_AVRouterImpl->castHandleToInfoMap_.insert({castHandle, castHandleInfo});
499
500 int32_t errorCode = -1;
501 std::string errorMsg = "**";
502 g_AVRouterImpl->OnCastEventRecv(errorCode, errorMsg);
503
504 EXPECT_TRUE(castHandleInfo.avRouterListener_ != nullptr);
505 SLOGI("OnCastEventRecv002 end");
506 }
507
508 /**
509 * @tc.name: DisconnectOtherSession001
510 * @tc.desc: listener is nullptr
511 * @tc.type: FUNC
512 * @tc.require: NA
513 */
514 static HWTEST_F(AVRouterImplTest, DisconnectOtherSession001, TestSize.Level1)
515 {
516 SLOGI("DisconnectOtherSession001 begin");
517 DeviceInfo deviceInfo;
518 deviceInfo.providerId_ = 1;
519
520 std::string sessionId = "12345";
521 std::shared_ptr<IAVRouterListener> listener = std::make_shared<AVRouterListenerMock>();
522 g_AVRouterImpl->mirrorSessionMap_.insert({sessionId, listener});
523
524 g_AVRouterImpl->DisconnectOtherSession(sessionId, deviceInfo);
525 EXPECT_TRUE(listener != nullptr);
526 SLOGI("DisconnectOtherSession001 end");
527 }
528
529 /**
530 * @tc.name: DisconnectOtherSession002
531 * @tc.desc: listener is nullptr
532 * @tc.type: FUNC
533 * @tc.require: NA
534 */
535 static HWTEST_F(AVRouterImplTest, DisconnectOtherSession002, TestSize.Level1)
536 {
537 SLOGI("DisconnectOtherSession002 begin");
538 DeviceInfo deviceInfo;
539 deviceInfo.providerId_ = 1;
540
541 std::string sessionId = "12345";
542 std::shared_ptr<IAVRouterListener> listener = nullptr;
543 g_AVRouterImpl->mirrorSessionMap_.insert({"12344", listener});
544
545 g_AVRouterImpl->DisconnectOtherSession(sessionId, deviceInfo);
546 EXPECT_TRUE(listener == nullptr);
547 SLOGI("DisconnectOtherSession002 end");
548 }
549
550 /**
551 * @tc.name: DisconnectOtherSession003
552 * @tc.desc: listener is nullptr
553 * @tc.type: FUNC
554 * @tc.require: NA
555 */
556 static HWTEST_F(AVRouterImplTest, DisconnectOtherSession003, TestSize.Level1)
557 {
558 SLOGI("DisconnectOtherSession003 begin");
559 OutputDeviceInfo outputDeviceInfo;
560 DeviceInfo deviceInfo;
561 deviceInfo.providerId_ = 1;
562 outputDeviceInfo.deviceInfos_.push_back(deviceInfo);
563
564 int64_t castHandle = 2000;
565 AVRouter::CastHandleInfo castHandleInfo;
566 castHandleInfo.sessionId_ = "12345";
567 castHandleInfo.outputDeviceInfo_ = outputDeviceInfo;
568 castHandleInfo.avRouterListener_ = std::make_shared<AVRouterListenerMock>();
569 g_AVRouterImpl->castHandleToInfoMap_.insert({castHandle, castHandleInfo});
570
571 std::string sessionId = "12345";
572 g_AVRouterImpl->DisconnectOtherSession(sessionId, deviceInfo);
573 EXPECT_TRUE(castHandleInfo.avRouterListener_ != nullptr);
574 SLOGI("DisconnectOtherSession003 end");
575 }
576
577 /**
578 * @tc.name: DisconnectOtherSession004
579 * @tc.desc: listener is nullptr
580 * @tc.type: FUNC
581 * @tc.require: NA
582 */
583 static HWTEST_F(AVRouterImplTest, DisconnectOtherSession004, TestSize.Level1)
584 {
585 SLOGI("DisconnectOtherSession004 begin");
586 OutputDeviceInfo outputDeviceInfo;
587 DeviceInfo deviceInfo;
588 deviceInfo.providerId_ = 1;
589 outputDeviceInfo.deviceInfos_.push_back(deviceInfo);
590
591 int64_t castHandle = 2000;
592 AVRouter::CastHandleInfo castHandleInfo;
593 castHandleInfo.sessionId_ = "12345";
594 castHandleInfo.outputDeviceInfo_ = outputDeviceInfo;
595 castHandleInfo.avRouterListener_ = std::make_shared<AVRouterListenerMock>();
596 g_AVRouterImpl->castHandleToInfoMap_.insert({castHandle, castHandleInfo});
597
598 std::string sessionId = "12340";
599 g_AVRouterImpl->DisconnectOtherSession(sessionId, deviceInfo);
600 EXPECT_TRUE(castHandleInfo.avRouterListener_ != nullptr);
601 SLOGI("DisconnectOtherSession004 end");
602 }
603
604 /**
605 * @tc.name: DisconnectOtherSession005
606 * @tc.desc: listener is nullptr
607 * @tc.type: FUNC
608 * @tc.require: NA
609 */
610 static HWTEST_F(AVRouterImplTest, DisconnectOtherSession005, TestSize.Level1)
611 {
612 SLOGI("DisconnectOtherSession005 begin");
613 OutputDeviceInfo outputDeviceInfo;
614 DeviceInfo deviceInfo;
615 deviceInfo.providerId_ = 1;
616 outputDeviceInfo.deviceInfos_.push_back(deviceInfo);
617
618 int64_t castHandle = 2000;
619 AVRouter::CastHandleInfo castHandleInfo;
620 castHandleInfo.sessionId_ = "12345";
621 castHandleInfo.outputDeviceInfo_ = outputDeviceInfo;
622 castHandleInfo.avRouterListener_ = nullptr;
623 g_AVRouterImpl->castHandleToInfoMap_.insert({castHandle, castHandleInfo});
624
625 std::string sessionId = "12340";
626 g_AVRouterImpl->DisconnectOtherSession(sessionId, deviceInfo);
627 EXPECT_TRUE(castHandleInfo.avRouterListener_ == nullptr);
628 SLOGI("DisconnectOtherSession005 end");
629 }
630
631 /**
632 * @tc.name: StartDeviceLogging001
633 * @tc.desc: the size of providerManagerMap_ bigger than zero
634 * @tc.type: FUNC
635 * @tc.require: NA
636 */
637 static HWTEST_F(AVRouterImplTest, StartDeviceLogging001, TestSize.Level1)
638 {
639 SLOGI("StartDeviceLogging001 begin");
640 int32_t fd = 0;
641 uint32_t maxSize = 0;
642 auto avCastProviderManager = std::make_shared<AVCastProviderManager>();
643 g_AVRouterImpl->providerManagerMap_.insert({fd, avCastProviderManager});
644 g_AVRouterImpl->StartDeviceLogging(fd, maxSize);
645 EXPECT_TRUE(!g_AVRouterImpl->providerManagerMap_.empty());
646 SLOGI("StartDeviceLogging001 end");
647 }
648
649 /**
650 * @tc.name: StopDeviceLogging001
651 * @tc.desc: set cacheStartDeviceLogging_ to false
652 * @tc.type: FUNC
653 * @tc.require: NA
654 */
655 static HWTEST_F(AVRouterImplTest, StopDeviceLogging001, TestSize.Level1)
656 {
657 SLOGI("StopDeviceLogging001 begin");
658 g_AVRouterImpl->cacheStartDeviceLogging_ = false;
659 g_AVRouterImpl->StopDeviceLogging();
660 EXPECT_TRUE(g_AVRouterImpl->cacheStartDeviceLogging_ == false);
661 SLOGI("StopDeviceLogging001 end");
662 }
663
664 /**
665 * @tc.name: StartCastDiscovery001
666 * @tc.desc: the size of providerManagerMap_ bigger than zero
667 * @tc.type: FUNC
668 * @tc.require: NA
669 */
670 static HWTEST_F(AVRouterImplTest, StartCastDiscovery001, TestSize.Level1)
671 {
672 SLOGI("StartCastDiscovery001 begin");
673 int32_t castDeviceCapability = 0;
674 std::vector<std::string> drmSchemes = {"test"};
675 auto avCastProviderManager = std::make_shared<AVCastProviderManager>();
676 g_AVRouterImpl->providerManagerMap_.insert({castDeviceCapability, avCastProviderManager});
677 g_AVRouterImpl->StartCastDiscovery(castDeviceCapability, drmSchemes);
678 EXPECT_TRUE(!g_AVRouterImpl->providerManagerMap_.empty());
679 SLOGI("StartCastDiscovery001 end");
680 }
681
682 /**
683 * @tc.name: StopCastDiscovery001
684 * @tc.desc: set cacheStartDeviceLogging_ to false
685 * @tc.type: FUNC
686 * @tc.require: NA
687 */
688 static HWTEST_F(AVRouterImplTest, StopCastDiscovery001, TestSize.Level1)
689 {
690 SLOGI("StopCastDiscovery001 begin");
691 g_AVRouterImpl->cacheStartDeviceLogging_ = false;
692 g_AVRouterImpl->StopCastDiscovery();
693 EXPECT_TRUE(g_AVRouterImpl->cacheStartDeviceLogging_ == false);
694 SLOGI("StopCastDiscovery001 end");
695 }
696
697 /**
698 * @tc.name: OnDeviceAvailable001
699 * @tc.desc: set servicePtr_ to not nullptr
700 * @tc.type: FUNC
701 * @tc.require: NA
702 */
703 static HWTEST_F(AVRouterImplTest, OnDeviceAvailable001, TestSize.Level1)
704 {
705 SLOGI("OnDeviceAvailable001 begin");
706 OutputDeviceInfo outputDeviceInfo;
707 DeviceInfo deviceInfo;
708 deviceInfo.providerId_ = 1;
709 outputDeviceInfo.deviceInfos_.push_back(deviceInfo);
710 auto listener = std::make_shared<AVSessionServiceListenerMock>();
711 g_AVRouterImpl->servicePtr_ = listener.get();
712 g_AVRouterImpl->OnDeviceAvailable(outputDeviceInfo);
713 EXPECT_TRUE(g_AVRouterImpl->servicePtr_ != nullptr);
714 SLOGI("OnDeviceAvailable001 end");
715 }
716
717 /**
718 * @tc.name: OnCastServerDied001
719 * @tc.desc: set servicePtr_ to not nullptr
720 * @tc.type: FUNC
721 * @tc.require: NA
722 */
723 static HWTEST_F(AVRouterImplTest, OnCastServerDied001, TestSize.Level1)
724 {
725 SLOGI("OnCastServerDied001 begin");
726 int32_t providerNumber = 0;
727 auto listener = std::make_shared<AVSessionServiceListenerMock>();
728 g_AVRouterImpl->servicePtr_ = listener.get();
729 g_AVRouterImpl->OnCastServerDied(providerNumber);
730 EXPECT_TRUE(g_AVRouterImpl->servicePtr_ != nullptr);
731 SLOGI("OnCastServerDied001 end");
732 }
733
734 /**
735 * @tc.name: GetRemoteController003
736 * @tc.desc: fail to get controller by handle
737 * @tc.type: FUNC
738 * @tc.require: NA
739 */
740 static HWTEST_F(AVRouterImplTest, GetRemoteController003, TestSize.Level1)
741 {
742 SLOGI("GetRemoteController003 begin");
743 g_AVRouterImpl->providerNumber_ = 1;
744 int32_t providerNumber = g_AVRouterImpl->providerNumber_;
745 int32_t castId = 1;
746 int64_t castHandle = static_cast<int64_t>((static_cast<uint64_t>(providerNumber) << 32) |
747 static_cast<uint32_t>(castId));
748
749 auto avCastProviderManager = std::make_shared<AVCastProviderManager>();
750 g_AVRouterImpl->providerManagerMap_[providerNumber] = avCastProviderManager;
751
752 int64_t handle = 2000;
753 AVRouter::CastHandleInfo castHandleInfo;
754 castHandleInfo.sessionId_ = "12345";
755 castHandleInfo.avRouterListener_ = std::make_shared<AVRouterListenerMock>();
756 g_AVRouterImpl->castHandleToInfoMap_[handle] = castHandleInfo;
757
758 auto controller = g_AVRouterImpl->GetRemoteController(castHandle);
759 EXPECT_TRUE(controller == nullptr);
760 SLOGI("GetRemoteController003 end");
761 }
762
763 /**
764 * @tc.name: GetRemoteController004
765 * @tc.desc: fail to get controller by handle
766 * @tc.type: FUNC
767 * @tc.require: NA
768 */
769 static HWTEST_F(AVRouterImplTest, GetRemoteController004, TestSize.Level1)
770 {
771 SLOGI("GetRemoteController004 begin");
772 g_AVRouterImpl->providerNumber_ = 1;
773 int32_t providerNumber = g_AVRouterImpl->providerNumber_;
774 int32_t castId = 1;
775 int64_t castHandle = static_cast<int64_t>((static_cast<uint64_t>(providerNumber) << 32) |
776 static_cast<uint32_t>(castId));
777
778 auto avCastProviderManager = std::make_shared<AVCastProviderManager>();
779 g_AVRouterImpl->providerManagerMap_[providerNumber] = avCastProviderManager;
780
781 AVRouter::CastHandleInfo castHandleInfo;
782 castHandleInfo.sessionId_ = "12345";
783 castHandleInfo.avRouterListener_ = std::make_shared<AVRouterListenerMock>();
784 g_AVRouterImpl->castHandleToInfoMap_[castHandle] = castHandleInfo;
785
786 auto controller = g_AVRouterImpl->GetRemoteController(castHandle);
787 EXPECT_TRUE(controller == nullptr);
788 SLOGI("GetRemoteController004 end");
789 }
790
791 /**
792 * @tc.name: StartCast004
793 * @tc.desc: the size of providerManagerMap_ bigger than zero
794 * @tc.type: FUNC
795 * @tc.require: NA
796 */
797 static HWTEST_F(AVRouterImplTest, StartCast004, TestSize.Level1)
798 {
799 SLOGI("StartCast004 begin");
800 g_AVRouterImpl->providerNumber_ = 1;
801 int32_t providerNumber = g_AVRouterImpl->providerNumber_;
802
803 OutputDeviceInfo outputDeviceInfo;
804 DeviceInfo deviceInfo;
805 deviceInfo.providerId_ = providerNumber;
806 outputDeviceInfo.deviceInfos_.push_back(deviceInfo);
807
808 auto avCastProviderManager = std::make_shared<AVCastProviderManager>();
809 auto hwCastProvider = std::make_shared<HwCastProvider>();
810 avCastProviderManager->Init(providerNumber, hwCastProvider);
811 g_AVRouterImpl->providerManagerMap_[providerNumber] = avCastProviderManager;
812
813 std::pair<std::string, std::string> serviceNameStatePair;
814 std::string sessionId = "1000";
815 AVRouter::CastHandleInfo castHandleInfo;
816 castHandleInfo.outputDeviceInfo_ = outputDeviceInfo;
817 castHandleInfo.sessionId_ = sessionId;
818 g_AVRouterImpl->castHandleToInfoMap_[providerNumber] = castHandleInfo;
819
820 auto ret = g_AVRouterImpl->StartCast(outputDeviceInfo, serviceNameStatePair, "1001");
821 EXPECT_TRUE(ret != AVSESSION_ERROR);
822 SLOGI("StartCast004 end");
823 }
824
825 /**
826 * @tc.name: StartCast005
827 * @tc.desc: the size of providerManagerMap_ bigger than zero
828 * @tc.type: FUNC
829 * @tc.require: NA
830 */
831 static HWTEST_F(AVRouterImplTest, StartCast005, TestSize.Level1)
832 {
833 SLOGI("StartCast005 begin");
834 g_AVRouterImpl->providerNumber_ = 1;
835 int32_t providerNumber = g_AVRouterImpl->providerNumber_;
836
837 OutputDeviceInfo outputDeviceInfo;
838 DeviceInfo deviceInfo;
839 deviceInfo.providerId_ = providerNumber;
840 outputDeviceInfo.deviceInfos_.push_back(deviceInfo);
841
842 auto avCastProviderManager = std::make_shared<AVCastProviderManager>();
843 auto hwCastProvider = std::make_shared<HwCastProvider>();
844 avCastProviderManager->Init(providerNumber, hwCastProvider);
845 g_AVRouterImpl->providerManagerMap_[providerNumber] = avCastProviderManager;
846
847 std::pair<std::string, std::string> serviceNameStatePair;
848 std::string sessionId = "1000";
849 AVRouter::CastHandleInfo castHandleInfo;
850 castHandleInfo.outputDeviceInfo_ = outputDeviceInfo;
851 castHandleInfo.sessionId_ = sessionId;
852 g_AVRouterImpl->castHandleToInfoMap_[providerNumber] = castHandleInfo;
853
854 OutputDeviceInfo outputDeviceInfo2;
855 DeviceInfo deviceInfo2;
856 deviceInfo2.providerId_ = providerNumber + 100;
857 outputDeviceInfo2.deviceInfos_.push_back(deviceInfo2);
858
859 auto ret = g_AVRouterImpl->StartCast(outputDeviceInfo2, serviceNameStatePair, sessionId);
860 EXPECT_TRUE(ret == AVSESSION_ERROR);
861 SLOGI("StartCast005 end");
862 }
863
864 /**
865 * @tc.name: StartCast006
866 * @tc.desc: the size of providerManagerMap_ bigger than zero
867 * @tc.type: FUNC
868 * @tc.require: NA
869 */
870 static HWTEST_F(AVRouterImplTest, StartCast006, TestSize.Level1)
871 {
872 SLOGI("StartCast006 begin");
873 g_AVRouterImpl->providerNumber_ = 1;
874 int32_t providerNumber = g_AVRouterImpl->providerNumber_;
875
876 OutputDeviceInfo outputDeviceInfo;
877 DeviceInfo deviceInfo;
878 deviceInfo.providerId_ = providerNumber;
879 outputDeviceInfo.deviceInfos_.push_back(deviceInfo);
880
881 auto avCastProviderManager = std::make_shared<AVCastProviderManager>();
882 auto hwCastProvider = std::make_shared<HwCastProvider>();
883 avCastProviderManager->Init(providerNumber, hwCastProvider);
884 g_AVRouterImpl->providerManagerMap_[providerNumber] = avCastProviderManager;
885
886 std::pair<std::string, std::string> serviceNameStatePair;
887 std::string sessionId = "1000";
888 AVRouter::CastHandleInfo castHandleInfo;
889 castHandleInfo.outputDeviceInfo_ = outputDeviceInfo;
890 castHandleInfo.sessionId_ = sessionId;
891 g_AVRouterImpl->castHandleToInfoMap_[providerNumber] = castHandleInfo;
892
893 auto ret = g_AVRouterImpl->StartCast(outputDeviceInfo, serviceNameStatePair, sessionId);
894 EXPECT_TRUE(ret == AVSESSION_ERROR);
895 SLOGI("StartCast006 end");
896 }
897
898 /**
899 * @tc.name: AddDevice005
900 * @tc.desc: success to add device
901 * @tc.type: FUNC
902 * @tc.require: NA
903 */
904 static HWTEST_F(AVRouterImplTest, AddDevice005, TestSize.Level1)
905 {
906 SLOGI("AddDevice005 begin");
907 g_AVRouterImpl->providerNumber_ = 1;
908 int32_t providerNumber = g_AVRouterImpl->providerNumber_;
909
910 OutputDeviceInfo outputDeviceInfo;
911 DeviceInfo deviceInfo;
912 deviceInfo.providerId_ = providerNumber;
913 outputDeviceInfo.deviceInfos_.push_back(deviceInfo);
914
915 int32_t castId = 1;
916 int64_t castHandle = static_cast<int64_t>((static_cast<uint64_t>(providerNumber) << 32) |
917 static_cast<uint32_t>(castId));
918
919 AVRouter::CastHandleInfo castHandleInfo;
920 castHandleInfo.outputDeviceInfo_ = outputDeviceInfo;
921 g_AVRouterImpl->castHandleToInfoMap_[castHandle] = castHandleInfo;
922
923 int32_t ret = g_AVRouterImpl->AddDevice(castId, outputDeviceInfo);
924 EXPECT_TRUE(ret == AVSESSION_SUCCESS);
925 SLOGI("AddDevice005 end");
926 }
927
928 /**
929 * @tc.name: AddDevice006
930 * @tc.desc: fail to add device
931 * @tc.type: FUNC
932 * @tc.require: NA
933 */
934 static HWTEST_F(AVRouterImplTest, AddDevice006, TestSize.Level1)
935 {
936 SLOGI("AddDevice006 begin");
937 g_AVRouterImpl->providerNumber_ = 1;
938 int32_t providerNumber = g_AVRouterImpl->providerNumber_;
939
940 OutputDeviceInfo outputDeviceInfo;
941 DeviceInfo deviceInfo;
942 deviceInfo.providerId_ = providerNumber;
943 outputDeviceInfo.deviceInfos_.push_back(deviceInfo);
944
945 int32_t castId = 1;
946 int64_t castHandle = static_cast<int64_t>((static_cast<uint64_t>(providerNumber) << 32) |
947 static_cast<uint32_t>(castId));
948
949 AVRouter::CastHandleInfo castHandleInfo;
950 castHandleInfo.outputDeviceInfo_ = outputDeviceInfo;
951 g_AVRouterImpl->castHandleToInfoMap_[castHandle] = castHandleInfo;
952
953 int32_t ret = g_AVRouterImpl->AddDevice(castId + 1, outputDeviceInfo);
954 EXPECT_TRUE(ret == ERR_DEVICE_CONNECTION_FAILED);
955 SLOGI("AddDevice006 end");
956 }
957
958 /**
959 * @tc.name: StopCast001
960 * @tc.desc: success to stop cast
961 * @tc.type: FUNC
962 * @tc.require: NA
963 */
964 static HWTEST_F(AVRouterImplTest, StopCast001, TestSize.Level1)
965 {
966 SLOGI("StopCast001 begin");
967 bool continuePlay = true;
968 g_AVRouterImpl->providerNumber_ = 1;
969 int32_t providerNumber = g_AVRouterImpl->providerNumber_;
970 int32_t castId = 1;
971 int64_t castHandle = static_cast<int64_t>((static_cast<uint64_t>(providerNumber) << 32) |
972 static_cast<uint32_t>(castId));
973
974 OutputDeviceInfo outputDeviceInfo;
975 DeviceInfo deviceInfo;
976 deviceInfo.providerId_ = providerNumber;
977 outputDeviceInfo.deviceInfos_.push_back(deviceInfo);
978
979 auto avCastProviderManager = std::make_shared<AVCastProviderManager>();
980 auto hwCastProvider = std::make_shared<HwCastProvider>();
981 avCastProviderManager->Init(providerNumber, hwCastProvider);
982 g_AVRouterImpl->providerManagerMap_[providerNumber] = avCastProviderManager;
983
984 std::string sessionId = "1000";
985 AVRouter::CastHandleInfo castHandleInfo;
986 castHandleInfo.outputDeviceInfo_ = outputDeviceInfo;
987 castHandleInfo.sessionId_ = sessionId;
988 g_AVRouterImpl->castHandleToInfoMap_[providerNumber] = castHandleInfo;
989
990 auto ret = g_AVRouterImpl->StopCast(castHandle, continuePlay);
991 EXPECT_TRUE(ret == AVSESSION_SUCCESS);
992 SLOGI("StopCast001 end");
993 }
994
995 /**
996 * @tc.name: StopCastSession001
997 * @tc.desc: success to stop cast session
998 * @tc.type: FUNC
999 * @tc.require: NA
1000 */
1001 static HWTEST_F(AVRouterImplTest, StopCastSession001, TestSize.Level1)
1002 {
1003 SLOGI("StopCastSession001 begin");
1004 g_AVRouterImpl->providerNumber_ = 1;
1005 int32_t providerNumber = g_AVRouterImpl->providerNumber_;
1006 int32_t castId = 1;
1007 int64_t castHandle = static_cast<int64_t>((static_cast<uint64_t>(providerNumber) << 32) |
1008 static_cast<uint32_t>(castId));
1009
1010 OutputDeviceInfo outputDeviceInfo;
1011 DeviceInfo deviceInfo;
1012 deviceInfo.providerId_ = providerNumber;
1013 outputDeviceInfo.deviceInfos_.push_back(deviceInfo);
1014
1015 auto avCastProviderManager = std::make_shared<AVCastProviderManager>();
1016 auto hwCastProvider = std::make_shared<HwCastProvider>();
1017 avCastProviderManager->Init(providerNumber, hwCastProvider);
1018 g_AVRouterImpl->providerManagerMap_[providerNumber] = avCastProviderManager;
1019
1020 AVRouter::CastHandleInfo castHandleInfo;
1021 castHandleInfo.outputDeviceInfo_ = outputDeviceInfo;
1022 g_AVRouterImpl->castHandleToInfoMap_[providerNumber] = castHandleInfo;
1023 g_AVRouterImpl->castHandleToInfoMap_[providerNumber + 100] = castHandleInfo;
1024
1025 auto ret = g_AVRouterImpl->StopCast(castHandle);
1026 EXPECT_TRUE(ret == AVSESSION_SUCCESS);
1027 SLOGI("StopCastSession001 end");
1028 }
1029
1030 } //AVSession
1031 } //OHOS