1 /*
2  * Copyright (c) 2024 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 "avcast_provider_manager.h"
18 #include "avsession_errors.h"
19 #include "avsession_log.h"
20 #include "avsession_service.h"
21 #include "hw_cast_stream_player.h"
22 #include "hw_cast_provider.h"
23 
24 using namespace testing::ext;
25 namespace OHOS::AVSession {
26 
27 static std::shared_ptr<AVSessionService> g_AVSessionService;
28 
29 class HwCastSupplementTest : public testing::Test {
30 public:
31     static void SetUpTestCase(void);
32     static void TearDownTestCase(void);
33     void SetUp();
34     void TearDown();
35 };
36 
SetUpTestCase()37 void HwCastSupplementTest::SetUpTestCase()
38 {
39     SLOGI("set up AVSessionServiceTest");
40     system("killall -9 com.example.hiMusicDemo");
41     g_AVSessionService = std::make_shared<AVSessionService>(OHOS::AVSESSION_SERVICE_ID);
42 }
43 
TearDownTestCase()44 void HwCastSupplementTest::TearDownTestCase()
45 {}
46 
SetUp()47 void HwCastSupplementTest::SetUp()
48 {}
49 
TearDown()50 void HwCastSupplementTest::TearDown()
51 {}
52 
53 class AVCastControllerProxyDemo : public IAVCastControllerProxy {
54 public:
55 
Release()56     void Release() {};
57 
RegisterControllerListener(const std::shared_ptr<IAVCastControllerProxyListener> iAVCastControllerProxyListener)58     int32_t RegisterControllerListener(const std::shared_ptr<IAVCastControllerProxyListener>
59         iAVCastControllerProxyListener) {return 0;}
60 
UnRegisterControllerListener(const std::shared_ptr<IAVCastControllerProxyListener> iAVCastControllerProxyListener)61     int32_t UnRegisterControllerListener(const std::shared_ptr<IAVCastControllerProxyListener>
62         iAVCastControllerProxyListener) {return 0;}
63 
GetCurrentItem()64     AVQueueItem GetCurrentItem() {return AVQueueItem();}
65 
Start(const AVQueueItem& avQueueItem)66     int32_t Start(const AVQueueItem& avQueueItem) {return 0;}
67 
Prepare(const AVQueueItem& avQueueItem)68     int32_t Prepare(const AVQueueItem& avQueueItem) {return 0;}
69 
SendControlCommand(const AVCastControlCommand cmd)70     void SendControlCommand(const AVCastControlCommand cmd) {}
71 
GetDuration(int32_t& duration)72     int32_t GetDuration(int32_t& duration) {return 0;}
73 
GetCastAVPlaybackState(AVPlaybackState& avPlaybackState)74     int32_t GetCastAVPlaybackState(AVPlaybackState& avPlaybackState) {return 0;}
75 
SetValidAbility(const std::vector<int32_t>& validAbilityList)76     int32_t SetValidAbility(const std::vector<int32_t>& validAbilityList) {return 0;}
77 
GetValidAbility(std::vector<int32_t> &validAbilityList)78     int32_t GetValidAbility(std::vector<int32_t> &validAbilityList) {return 0;}
79 
SetDisplaySurface(std::string& surfaceId)80     int32_t SetDisplaySurface(std::string& surfaceId) {return 0;}
81 
ProcessMediaKeyResponse(const std::string& assetId, const std::vector<uint8_t>& response)82     int32_t ProcessMediaKeyResponse(const std::string& assetId, const std::vector<uint8_t>& response) {return 0;}
83 };
84 
85 class AVCastSessionStateListenerDemo : public IAVCastSessionStateListener {
86 public:
OnCastStateChange(int32_t castState, DeviceInfo deviceInfo)87     void OnCastStateChange(int32_t castState, DeviceInfo deviceInfo) {}
88 
OnCastEventRecv(int32_t errorCode, std::string& errorMsg)89     void OnCastEventRecv(int32_t errorCode, std::string& errorMsg) {}
90 };
91 
92 /**
93  * @tc.name: StopCastSession001
94  * @tc.desc: test StopCastSession
95  * @tc.type: FUNC
96  */
HWTEST(HwCastSupplementTest, StopCastSession001, TestSize.Level1)97 static HWTEST(HwCastSupplementTest, StopCastSession001, TestSize.Level1)
98 {
99     SLOGI("StopCastSession001 begin!");
100     std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
101     EXPECT_EQ(hwCastProvider != nullptr, true);
102     hwCastProvider->Init();
103 
104     int32_t castId = 0;
105     hwCastProvider->hwCastProviderSessionMap_[castId] = nullptr;
106     hwCastProvider->StopCastSession(castId);
107     SLOGI("StopCastSession001 end!");
108 }
109 
110 /**
111  * @tc.name: StopCastSession002
112  * @tc.desc: test StopCastSession
113  * @tc.type: FUNC
114  */
HWTEST(HwCastSupplementTest, StopCastSession002, TestSize.Level1)115 static HWTEST(HwCastSupplementTest, StopCastSession002, TestSize.Level1)
116 {
117     SLOGI("StopCastSession002 begin!");
118     std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
119     EXPECT_EQ(hwCastProvider != nullptr, true);
120     hwCastProvider->Init();
121 
122     int32_t castId = 0;
123     auto hwCastProviderSession = std::make_shared<HwCastProviderSession>(nullptr);
124     hwCastProvider->hwCastProviderSessionMap_[castId] = hwCastProviderSession;
125     hwCastProvider->StopCastSession(castId);
126     SLOGI("StopCastSession002 end!");
127 }
128 
129 /**
130  * @tc.name: StopCastSession003
131  * @tc.desc: test StopCastSession
132  * @tc.type: FUNC
133  */
HWTEST(HwCastSupplementTest, StopCastSession003, TestSize.Level1)134 static HWTEST(HwCastSupplementTest, StopCastSession003, TestSize.Level1)
135 {
136     SLOGI("StopCastSession003 begin!");
137     std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
138     EXPECT_EQ(hwCastProvider != nullptr, true);
139     hwCastProvider->Init();
140 
141     int32_t castId = -1;
142     auto hwCastProviderSession = std::make_shared<HwCastProviderSession>(nullptr);
143     hwCastProvider->hwCastProviderSessionMap_[castId] = hwCastProviderSession;
144     hwCastProvider->StopCastSession(castId);
145     SLOGI("StopCastSession003 end!");
146 }
147 
148 /**
149  * @tc.name: AddCastDevice001
150  * @tc.desc: test AddCastDevice
151  * @tc.type: FUNC
152  */
HWTEST(HwCastSupplementTest, AddCastDevice001, TestSize.Level1)153 static HWTEST(HwCastSupplementTest, AddCastDevice001, TestSize.Level1)
154 {
155     SLOGI("AddCastDevice001 begin!");
156     std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
157     EXPECT_EQ(hwCastProvider != nullptr, true);
158     hwCastProvider->Init();
159 
160     int32_t castId = 0;
161     DeviceInfo deviceInfo;
162     bool ret = hwCastProvider->AddCastDevice(castId, deviceInfo);
163     EXPECT_EQ(ret, false);
164     SLOGI("AddCastDevice001 end!");
165 }
166 
167 /**
168  * @tc.name: AddCastDevice002
169  * @tc.desc: test AddCastDevice
170  * @tc.type: FUNC
171  */
HWTEST(HwCastSupplementTest, AddCastDevice002, TestSize.Level1)172 static HWTEST(HwCastSupplementTest, AddCastDevice002, TestSize.Level1)
173 {
174     SLOGI("AddCastDevice002 begin!");
175     std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
176     EXPECT_EQ(hwCastProvider != nullptr, true);
177     hwCastProvider->Init();
178 
179     int32_t castId = 0;
180     DeviceInfo deviceInfo;
181     hwCastProvider->hwCastProviderSessionMap_[castId] = nullptr;
182     bool ret = hwCastProvider->AddCastDevice(castId, deviceInfo);
183     EXPECT_EQ(ret, false);
184     SLOGI("AddCastDevice002 end!");
185 }
186 
187 /**
188  * @tc.name: AddCastDevice003
189  * @tc.desc: test AddCastDevice
190  * @tc.type: FUNC
191  */
HWTEST(HwCastSupplementTest, AddCastDevice003, TestSize.Level1)192 static HWTEST(HwCastSupplementTest, AddCastDevice003, TestSize.Level1)
193 {
194     SLOGI("AddCastDevice003 begin!");
195     std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
196     EXPECT_EQ(hwCastProvider != nullptr, true);
197     hwCastProvider->Init();
198 
199     int32_t castId = 0;
200     DeviceInfo deviceInfo;
201     auto hwCastProviderSession = std::make_shared<HwCastProviderSession>(nullptr);
202     hwCastProvider->hwCastProviderSessionMap_[castId] = hwCastProviderSession;
203     bool ret = hwCastProvider->AddCastDevice(castId, deviceInfo);
204     EXPECT_EQ(ret, false);
205     SLOGI("AddCastDevice003 end!");
206 }
207 
208 /**
209  * @tc.name: RemoveCastDevice001
210  * @tc.desc: test RemoveCastDevice
211  * @tc.type: FUNC
212  */
HWTEST(HwCastSupplementTest, RemoveCastDevice001, TestSize.Level1)213 static HWTEST(HwCastSupplementTest, RemoveCastDevice001, TestSize.Level1)
214 {
215     SLOGI("RemoveCastDevice001 begin!");
216     std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
217     EXPECT_EQ(hwCastProvider != nullptr, true);
218     hwCastProvider->Init();
219 
220     int32_t castId = 0;
221     DeviceInfo deviceInfo;
222     bool ret = hwCastProvider->RemoveCastDevice(castId, deviceInfo);
223     EXPECT_EQ(ret, false);
224     SLOGI("RemoveCastDevice001 end!");
225 }
226 
227 /**
228  * @tc.name: RemoveCastDevice002
229  * @tc.desc: test RemoveCastDevice
230  * @tc.type: FUNC
231  */
HWTEST(HwCastSupplementTest, RemoveCastDevice002, TestSize.Level1)232 static HWTEST(HwCastSupplementTest, RemoveCastDevice002, TestSize.Level1)
233 {
234     SLOGI("RemoveCastDevice002 begin!");
235     std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
236     EXPECT_EQ(hwCastProvider != nullptr, true);
237     hwCastProvider->Init();
238 
239     int32_t castId = 0;
240     DeviceInfo deviceInfo;
241     hwCastProvider->hwCastProviderSessionMap_[castId] = nullptr;
242     bool ret = hwCastProvider->RemoveCastDevice(castId, deviceInfo);
243     EXPECT_EQ(ret, false);
244     SLOGI("RemoveCastDevice002 end!");
245 }
246 
247 /**
248  * @tc.name: RemoveCastDevice003
249  * @tc.desc: test RemoveCastDevice
250  * @tc.type: FUNC
251  */
HWTEST(HwCastSupplementTest, RemoveCastDevice003, TestSize.Level1)252 static HWTEST(HwCastSupplementTest, RemoveCastDevice003, TestSize.Level1)
253 {
254     SLOGI("RemoveCastDevice003 begin!");
255     std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
256     EXPECT_EQ(hwCastProvider != nullptr, true);
257     hwCastProvider->Init();
258 
259     int32_t castId = 0;
260     DeviceInfo deviceInfo;
261     auto hwCastProviderSession = std::make_shared<HwCastProviderSession>(nullptr);
262     hwCastProvider->hwCastProviderSessionMap_[castId] = hwCastProviderSession;
263     bool ret = hwCastProvider->RemoveCastDevice(castId, deviceInfo);
264     EXPECT_EQ(ret, false);
265     SLOGI("RemoveCastDevice003 end!");
266 }
267 
268 /**
269  * @tc.name: RegisterCastStateListener001
270  * @tc.desc: test RegisterCastStateListener
271  * @tc.type: FUNC
272  */
HWTEST(HwCastSupplementTest, RegisterCastStateListener001, TestSize.Level1)273 static HWTEST(HwCastSupplementTest, RegisterCastStateListener001, TestSize.Level1)
274 {
275     SLOGI("RegisterCastStateListener001 begin!");
276     std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
277     EXPECT_EQ(hwCastProvider != nullptr, true);
278     hwCastProvider->Init();
279 
280     std::shared_ptr<AVCastProviderManager> avCastStateListenerDemo =
281         std::make_shared<AVCastProviderManager>();
282     bool ret = hwCastProvider->RegisterCastStateListener(avCastStateListenerDemo);
283     EXPECT_EQ(ret, true);
284     SLOGI("RegisterCastStateListener001 end!");
285 }
286 
287 /**
288  * @tc.name: UnRegisterCastStateListener001
289  * @tc.desc: test UnRegisterCastStateListener
290  * @tc.type: FUNC
291  */
HWTEST(HwCastSupplementTest, UnRegisterCastStateListener001, TestSize.Level1)292 static HWTEST(HwCastSupplementTest, UnRegisterCastStateListener001, TestSize.Level1)
293 {
294     SLOGI("UnRegisterCastStateListener001 begin!");
295     std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
296     EXPECT_EQ(hwCastProvider != nullptr, true);
297     hwCastProvider->Init();
298 
299     std::shared_ptr<AVCastProviderManager> avCastStateListenerDemo =
300         std::make_shared<AVCastProviderManager>();
301     hwCastProvider->RegisterCastStateListener(avCastStateListenerDemo);
302     bool ret = hwCastProvider->UnRegisterCastStateListener(avCastStateListenerDemo);
303     EXPECT_EQ(ret, true);
304     SLOGI("UnRegisterCastStateListener001 end!");
305 }
306 
307 /**
308  * @tc.name: UnRegisterCastStateListener002
309  * @tc.desc: test UnRegisterCastStateListener
310  * @tc.type: FUNC
311  */
HWTEST(HwCastSupplementTest, UnRegisterCastStateListener002, TestSize.Level1)312 static HWTEST(HwCastSupplementTest, UnRegisterCastStateListener002, TestSize.Level1)
313 {
314     SLOGI("UnRegisterCastStateListener002 begin!");
315     std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
316     EXPECT_EQ(hwCastProvider != nullptr, true);
317     hwCastProvider->Init();
318 
319     std::shared_ptr<AVCastProviderManager> avCastStateListenerDemo =
320         std::make_shared<AVCastProviderManager>();
321     bool ret = hwCastProvider->UnRegisterCastStateListener(avCastStateListenerDemo);
322     EXPECT_EQ(ret, false);
323     SLOGI("UnRegisterCastStateListener002 end!");
324 }
325 
326 /**
327  * @tc.name: UnRegisterCastStateListener003
328  * @tc.desc: test UnRegisterCastStateListener
329  * @tc.type: FUNC
330  */
HWTEST(HwCastSupplementTest, UnRegisterCastStateListener003, TestSize.Level1)331 static HWTEST(HwCastSupplementTest, UnRegisterCastStateListener003, TestSize.Level1)
332 {
333     SLOGI("UnRegisterCastStateListener003 begin!");
334     std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
335     EXPECT_EQ(hwCastProvider != nullptr, true);
336     hwCastProvider->Init();
337 
338     std::shared_ptr<IAVCastStateListener> avCastStateListenerDemo = nullptr;
339     bool ret = hwCastProvider->UnRegisterCastStateListener(avCastStateListenerDemo);
340     EXPECT_EQ(ret, false);
341     SLOGI("UnRegisterCastStateListener003 end!");
342 }
343 
344 /**
345  * @tc.name: RegisterCastSessionStateListener001
346  * @tc.desc: test RegisterCastSessionStateListener
347  * @tc.type: FUNC
348  */
HWTEST(HwCastSupplementTest, RegisterCastSessionStateListener001, TestSize.Level1)349 static HWTEST(HwCastSupplementTest, RegisterCastSessionStateListener001, TestSize.Level1)
350 {
351     SLOGI("RegisterCastSessionStateListener001 begin!");
352     std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
353     EXPECT_EQ(hwCastProvider != nullptr, true);
354     hwCastProvider->Init();
355 
356     int castId = 0;
357     std::shared_ptr<IAVCastSessionStateListener> listener =
358         std::make_shared<AVCastSessionStateListenerDemo>();
359     bool ret = hwCastProvider->RegisterCastSessionStateListener(castId, listener);
360     EXPECT_EQ(ret, false);
361     SLOGI("RegisterCastSessionStateListener001 end!");
362 }
363 
364 /**
365  * @tc.name: RegisterCastSessionStateListener002
366  * @tc.desc: test RegisterCastSessionStateListener
367  * @tc.type: FUNC
368  */
HWTEST(HwCastSupplementTest, RegisterCastSessionStateListener002, TestSize.Level1)369 static HWTEST(HwCastSupplementTest, RegisterCastSessionStateListener002, TestSize.Level1)
370 {
371     SLOGI("RegisterCastSessionStateListener002 begin!");
372     std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
373     EXPECT_EQ(hwCastProvider != nullptr, true);
374     hwCastProvider->Init();
375 
376     int castId = 0;
377     std::shared_ptr<IAVCastSessionStateListener> listener =
378         std::make_shared<AVCastSessionStateListenerDemo>();
379     hwCastProvider->hwCastProviderSessionMap_[castId] = nullptr;
380     bool ret = hwCastProvider->RegisterCastSessionStateListener(castId, listener);
381     EXPECT_EQ(ret, false);
382     SLOGI("RegisterCastSessionStateListener002 end!");
383 }
384 
385 /**
386  * @tc.name: RegisterCastSessionStateListener003
387  * @tc.desc: test RegisterCastSessionStateListener
388  * @tc.type: FUNC
389  */
HWTEST(HwCastSupplementTest, RegisterCastSessionStateListener003, TestSize.Level1)390 static HWTEST(HwCastSupplementTest, RegisterCastSessionStateListener003, TestSize.Level1)
391 {
392     SLOGI("RegisterCastSessionStateListener003 begin!");
393     std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
394     EXPECT_EQ(hwCastProvider != nullptr, true);
395     hwCastProvider->Init();
396 
397     int castId = 0;
398     std::shared_ptr<IAVCastSessionStateListener> listener =
399         std::make_shared<AVCastSessionStateListenerDemo>();
400     auto hwCastProviderSession = std::make_shared<HwCastProviderSession>(nullptr);
401     hwCastProvider->hwCastProviderSessionMap_[castId] = hwCastProviderSession;
402     bool ret = hwCastProvider->RegisterCastSessionStateListener(castId, listener);
403     EXPECT_EQ(ret, true);
404     SLOGI("RegisterCastSessionStateListener003 end!");
405 }
406 
407 /**
408  * @tc.name: UnRegisterCastSessionStateListener001
409  * @tc.desc: test UnRegisterCastSessionStateListener
410  * @tc.type: FUNC
411  */
HWTEST(HwCastSupplementTest, UnRegisterCastSessionStateListener001, TestSize.Level1)412 static HWTEST(HwCastSupplementTest, UnRegisterCastSessionStateListener001, TestSize.Level1)
413 {
414     SLOGI("UnRegisterCastSessionStateListener001 begin!");
415     std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
416     EXPECT_EQ(hwCastProvider != nullptr, true);
417     hwCastProvider->Init();
418 
419     int castId = 0;
420     std::shared_ptr<IAVCastSessionStateListener> listener =
421         std::make_shared<AVCastSessionStateListenerDemo>();
422     bool ret = hwCastProvider->UnRegisterCastSessionStateListener(castId, listener);
423     EXPECT_EQ(ret, false);
424     SLOGI("UnRegisterCastSessionStateListener001 end!");
425 }
426 
427 /**
428  * @tc.name: UnRegisterCastSessionStateListener002
429  * @tc.desc: test UnRegisterCastSessionStateListener
430  * @tc.type: FUNC
431  */
HWTEST(HwCastSupplementTest, UnRegisterCastSessionStateListener002, TestSize.Level1)432 static HWTEST(HwCastSupplementTest, UnRegisterCastSessionStateListener002, TestSize.Level1)
433 {
434     SLOGI("UnRegisterCastSessionStateListener002 begin!");
435     std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
436     EXPECT_EQ(hwCastProvider != nullptr, true);
437     hwCastProvider->Init();
438 
439     int castId = 0;
440     std::shared_ptr<IAVCastSessionStateListener> listener =
441         std::make_shared<AVCastSessionStateListenerDemo>();
442     hwCastProvider->hwCastProviderSessionMap_[castId] = nullptr;
443     bool ret = hwCastProvider->UnRegisterCastSessionStateListener(castId, listener);
444     EXPECT_EQ(ret, false);
445     SLOGI("UnRegisterCastSessionStateListener002 end!");
446 }
447 
448 /**
449  * @tc.name: UnRegisterCastSessionStateListener003
450  * @tc.desc: test UnRegisterCastSessionStateListener
451  * @tc.type: FUNC
452  */
HWTEST(HwCastSupplementTest, UnRegisterCastSessionStateListener003, TestSize.Level1)453 static HWTEST(HwCastSupplementTest, UnRegisterCastSessionStateListener003, TestSize.Level1)
454 {
455     SLOGI("UnRegisterCastSessionStateListener003 begin!");
456     std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
457     EXPECT_EQ(hwCastProvider != nullptr, true);
458     hwCastProvider->Init();
459 
460     int castId = 0;
461     std::shared_ptr<IAVCastSessionStateListener> listener =
462         std::make_shared<AVCastSessionStateListenerDemo>();
463     auto hwCastProviderSession = std::make_shared<HwCastProviderSession>(nullptr);
464     hwCastProvider->hwCastProviderSessionMap_[castId] = hwCastProviderSession;
465     bool ret = hwCastProvider->UnRegisterCastSessionStateListener(castId, listener);
466     EXPECT_EQ(ret, false);
467     SLOGI("UnRegisterCastSessionStateListener003 end!");
468 }
469 
470 /**
471  * @tc.name: GetRemoteController001
472  * @tc.desc: test GetRemoteController
473  * @tc.type: FUNC
474  */
HWTEST(HwCastSupplementTest, GetRemoteController001, TestSize.Level1)475 static HWTEST(HwCastSupplementTest, GetRemoteController001, TestSize.Level1)
476 {
477     SLOGI("GetRemoteController001 begin!");
478     std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
479     EXPECT_EQ(hwCastProvider != nullptr, true);
480     hwCastProvider->Init();
481 
482     int castId = 0;
483     auto ret = hwCastProvider->GetRemoteController(castId);
484     EXPECT_EQ(ret, nullptr);
485     SLOGI("GetRemoteController001 end!");
486 }
487 
488 /**
489  * @tc.name: GetRemoteController002
490  * @tc.desc: test GetRemoteController
491  * @tc.type: FUNC
492  */
HWTEST(HwCastSupplementTest, GetRemoteController002, TestSize.Level1)493 static HWTEST(HwCastSupplementTest, GetRemoteController002, TestSize.Level1)
494 {
495     SLOGI("GetRemoteController002 begin!");
496     std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
497     EXPECT_EQ(hwCastProvider != nullptr, true);
498     hwCastProvider->Init();
499 
500     int castId = 0;
501     hwCastProvider->avCastControllerMap_[castId] = nullptr;
502     auto ret = hwCastProvider->GetRemoteController(castId);
503     EXPECT_EQ(ret, nullptr);
504     SLOGI("GetRemoteController002 end!");
505 }
506 
507 /**
508  * @tc.name: GetRemoteController003
509  * @tc.desc: test GetRemoteController
510  * @tc.type: FUNC
511  */
HWTEST(HwCastSupplementTest, GetRemoteController003, TestSize.Level1)512 static HWTEST(HwCastSupplementTest, GetRemoteController003, TestSize.Level1)
513 {
514     SLOGI("GetRemoteController003 begin!");
515     std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
516     EXPECT_EQ(hwCastProvider != nullptr, true);
517     hwCastProvider->Init();
518 
519     int castId = 0;
520     hwCastProvider->hwCastProviderSessionMap_[castId] = nullptr;
521     auto ret = hwCastProvider->GetRemoteController(castId);
522     EXPECT_EQ(ret, nullptr);
523     SLOGI("GetRemoteController003 end!");
524 }
525 
526 /**
527  * @tc.name: GetRemoteController004
528  * @tc.desc: test GetRemoteController
529  * @tc.type: FUNC
530  */
HWTEST(HwCastSupplementTest, GetRemoteController004, TestSize.Level1)531 static HWTEST(HwCastSupplementTest, GetRemoteController004, TestSize.Level1)
532 {
533     SLOGI("GetRemoteController003 begin!");
534     std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
535     EXPECT_EQ(hwCastProvider != nullptr, true);
536     hwCastProvider->Init();
537 
538     int castId = 0;
539     auto hwCastProviderSession = std::make_shared<HwCastProviderSession>(nullptr);
540     hwCastProvider->hwCastProviderSessionMap_[castId] = hwCastProviderSession;
541     auto ret = hwCastProvider->GetRemoteController(castId);
542     EXPECT_NE(ret, nullptr);
543     SLOGI("GetRemoteController003 end!");
544 }
545 
546 /**
547  * @tc.name: SetStreamState001
548  * @tc.desc: test SetStreamState
549  * @tc.type: FUNC
550  */
HWTEST(HwCastSupplementTest, SetStreamState001, TestSize.Level1)551 static HWTEST(HwCastSupplementTest, SetStreamState001, TestSize.Level1)
552 {
553     SLOGI("SetStreamState001 begin!");
554     std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
555     EXPECT_EQ(hwCastProvider != nullptr, true);
556     hwCastProvider->Init();
557 
558     int castId = 0;
559     DeviceInfo deviceInfo;
560     bool ret = hwCastProvider->SetStreamState(castId, deviceInfo);
561     EXPECT_EQ(ret, false);
562     SLOGI("SetStreamState001 end!");
563 }
564 
565 /**
566  * @tc.name: SetStreamState002
567  * @tc.desc: test SetStreamState
568  * @tc.type: FUNC
569  */
HWTEST(HwCastSupplementTest, SetStreamState002, TestSize.Level1)570 static HWTEST(HwCastSupplementTest, SetStreamState002, TestSize.Level1)
571 {
572     SLOGI("SetStreamState002 begin!");
573     std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
574     EXPECT_EQ(hwCastProvider != nullptr, true);
575     hwCastProvider->Init();
576 
577     int castId = 0;
578     DeviceInfo deviceInfo;
579     hwCastProvider->hwCastProviderSessionMap_[castId] = nullptr;
580     bool ret = hwCastProvider->SetStreamState(castId, deviceInfo);
581     EXPECT_EQ(ret, false);
582     SLOGI("SetStreamState002 end!");
583 }
584 
585 /**
586  * @tc.name: SetStreamState003
587  * @tc.desc: test SetStreamState
588  * @tc.type: FUNC
589  */
HWTEST(HwCastSupplementTest, SetStreamState003, TestSize.Level1)590 static HWTEST(HwCastSupplementTest, SetStreamState003, TestSize.Level1)
591 {
592     SLOGI("SetStreamState003 begin!");
593     std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
594     EXPECT_EQ(hwCastProvider != nullptr, true);
595     hwCastProvider->Init();
596 
597     int castId = 0;
598     DeviceInfo deviceInfo;
599     auto hwCastProviderSession = std::make_shared<HwCastProviderSession>(nullptr);
600     hwCastProvider->hwCastProviderSessionMap_[castId] = hwCastProviderSession;
601     bool ret = hwCastProvider->SetStreamState(castId, deviceInfo);
602     EXPECT_EQ(ret, true);
603     SLOGI("SetStreamState003 end!");
604 }
605 
606 /**
607  * @tc.name: GetRemoteNetWorkId001
608  * @tc.desc: test GetRemoteNetWorkId
609  * @tc.type: FUNC
610  */
HWTEST(HwCastSupplementTest, GetRemoteNetWorkId001, TestSize.Level1)611 static HWTEST(HwCastSupplementTest, GetRemoteNetWorkId001, TestSize.Level1)
612 {
613     SLOGI("GetRemoteNetWorkId001 begin!");
614     std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
615     EXPECT_EQ(hwCastProvider != nullptr, true);
616     hwCastProvider->Init();
617 
618     int castId = 0;
619     std::string deviceId;
620     std::string networkId;
621     bool ret = hwCastProvider->GetRemoteNetWorkId(castId, deviceId, networkId);
622     EXPECT_EQ(ret, false);
623     SLOGI("GetRemoteNetWorkId001 end!");
624 }
625 
626 /**
627  * @tc.name: GetRemoteNetWorkId002
628  * @tc.desc: test GetRemoteNetWorkId
629  * @tc.type: FUNC
630  */
HWTEST(HwCastSupplementTest, GetRemoteNetWorkId002, TestSize.Level1)631 static HWTEST(HwCastSupplementTest, GetRemoteNetWorkId002, TestSize.Level1)
632 {
633     SLOGI("GetRemoteNetWorkId002 begin!");
634     std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
635     EXPECT_EQ(hwCastProvider != nullptr, true);
636     hwCastProvider->Init();
637 
638     int castId = 0;
639     std::string deviceId;
640     std::string networkId;
641     hwCastProvider->hwCastProviderSessionMap_[castId] = nullptr;
642     bool ret = hwCastProvider->GetRemoteNetWorkId(castId, deviceId, networkId);
643     EXPECT_EQ(ret, false);
644     SLOGI("GetRemoteNetWorkId002 end!");
645 }
646 
647 /**
648  * @tc.name: GetRemoteNetWorkId003
649  * @tc.desc: test GetRemoteNetWorkId
650  * @tc.type: FUNC
651  */
HWTEST(HwCastSupplementTest, GetRemoteNetWorkId003, TestSize.Level1)652 static HWTEST(HwCastSupplementTest, GetRemoteNetWorkId003, TestSize.Level1)
653 {
654     SLOGI("GetRemoteNetWorkId003 begin!");
655     std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
656     EXPECT_EQ(hwCastProvider != nullptr, true);
657     hwCastProvider->Init();
658 
659     int castId = 0;
660     std::string deviceId;
661     std::string networkId;
662     auto hwCastProviderSession = std::make_shared<HwCastProviderSession>(nullptr);
663     hwCastProvider->hwCastProviderSessionMap_[castId] = hwCastProviderSession;
664     bool ret = hwCastProvider->GetRemoteNetWorkId(castId, deviceId, networkId);
665     EXPECT_EQ(ret, false);
666     SLOGI("GetRemoteNetWorkId003 end!");
667 }
668 
669 /**
670  * @tc.name: OnDeviceFound001
671  * @tc.desc: test OnDeviceFound
672  * @tc.type: FUNC
673  */
HWTEST(HwCastSupplementTest, OnDeviceFound001, TestSize.Level1)674 static HWTEST(HwCastSupplementTest, OnDeviceFound001, TestSize.Level1)
675 {
676     SLOGI("OnDeviceFound001 begin!");
677     std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
678     EXPECT_EQ(hwCastProvider != nullptr, true);
679     hwCastProvider->Init();
680 
681     CastEngine::CastRemoteDevice castRemoteDevice;
682     std::vector<CastEngine::CastRemoteDevice> deviceList;
683     deviceList.push_back(castRemoteDevice);
684 
685     std::shared_ptr<AVCastProviderManager> ptr = std::make_shared<AVCastProviderManager>();
686     hwCastProvider->castStateListenerList_.push_back(ptr);
687 
688     hwCastProvider->OnDeviceFound(deviceList);
689     SLOGI("OnDeviceFound001 end!");
690 }
691 
692 /**
693  * @tc.name: OnDeviceFound002
694  * @tc.desc: test OnDeviceFound
695  * @tc.type: FUNC
696  */
HWTEST(HwCastSupplementTest, OnDeviceFound002, TestSize.Level1)697 static HWTEST(HwCastSupplementTest, OnDeviceFound002, TestSize.Level1)
698 {
699     SLOGI("OnDeviceFound002 begin!");
700     std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
701     EXPECT_EQ(hwCastProvider != nullptr, true);
702     hwCastProvider->Init();
703 
704     CastEngine::CastRemoteDevice castRemoteDevice;
705     std::vector<CastEngine::CastRemoteDevice> deviceList;
706     deviceList.push_back(castRemoteDevice);
707 
708     std::shared_ptr<IAVCastStateListener> ptr = nullptr;
709     hwCastProvider->castStateListenerList_.push_back(ptr);
710 
711     hwCastProvider->OnDeviceFound(deviceList);
712     SLOGI("OnDeviceFound002 end!");
713 }
714 
715 /**
716  * @tc.name: OnLogEvent001
717  * @tc.desc: test OnLogEvent
718  * @tc.type: FUNC
719  */
HWTEST(HwCastSupplementTest, OnLogEvent001, TestSize.Level1)720 static HWTEST(HwCastSupplementTest, OnLogEvent001, TestSize.Level1)
721 {
722     SLOGI("OnLogEvent001 begin!");
723     std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
724     EXPECT_EQ(hwCastProvider != nullptr, true);
725     hwCastProvider->Init();
726 
727     std::shared_ptr<IAVCastStateListener> ptr = nullptr;
728     hwCastProvider->castStateListenerList_.push_back(ptr);
729 
730     int32_t eventId = 0;
731     int64_t param = 0;
732     hwCastProvider->OnLogEvent(eventId, param);
733     SLOGI("OnLogEvent001 end!");
734 }
735 
736 /**
737  * @tc.name: OnLogEvent002
738  * @tc.desc: test OnLogEvent
739  * @tc.type: FUNC
740  */
HWTEST(HwCastSupplementTest, OnLogEvent002, TestSize.Level1)741 static HWTEST(HwCastSupplementTest, OnLogEvent002, TestSize.Level1)
742 {
743     SLOGI("OnLogEvent002 begin!");
744     std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
745     EXPECT_EQ(hwCastProvider != nullptr, true);
746     hwCastProvider->Init();
747 
748     std::shared_ptr<AVCastProviderManager> ptr = std::make_shared<AVCastProviderManager>();
749     hwCastProvider->castStateListenerList_.push_back(ptr);
750 
751     int32_t eventId = 0;
752     int64_t param = 0;
753     hwCastProvider->OnLogEvent(eventId, param);
754     SLOGI("OnLogEvent002 end!");
755 }
756 
757 /**
758  * @tc.name: OnLogEvent003
759  * @tc.desc: test OnLogEvent
760  * @tc.type: FUNC
761  */
HWTEST(HwCastSupplementTest, OnLogEvent003, TestSize.Level1)762 static HWTEST(HwCastSupplementTest, OnLogEvent003, TestSize.Level1)
763 {
764     SLOGI("OnLogEvent003 begin!");
765     std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
766     EXPECT_EQ(hwCastProvider != nullptr, true);
767     hwCastProvider->Init();
768 
769     std::shared_ptr<AVCastProviderManager> ptr = std::make_shared<AVCastProviderManager>();
770     hwCastProvider->castStateListenerList_.push_back(ptr);
771 
772     int32_t eventId = 1;
773     int64_t param = 0;
774     hwCastProvider->OnLogEvent(eventId, param);
775     SLOGI("OnLogEvent003 end!");
776 }
777 
778 /**
779  * @tc.name: OnDeviceOffline001
780  * @tc.desc: test OnDeviceOffline
781  * @tc.type: FUNC
782  */
HWTEST(HwCastSupplementTest, OnDeviceOffline001, TestSize.Level1)783 static HWTEST(HwCastSupplementTest, OnDeviceOffline001, TestSize.Level1)
784 {
785     SLOGI("OnDeviceOffline001 begin!");
786     std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
787     EXPECT_EQ(hwCastProvider != nullptr, true);
788     hwCastProvider->Init();
789 
790     std::shared_ptr<IAVCastStateListener> ptr = nullptr;
791     hwCastProvider->castStateListenerList_.push_back(ptr);
792 
793     std::string deviceId = "111";
794     hwCastProvider->OnDeviceOffline(deviceId);
795     SLOGI("OnDeviceOffline001 end!");
796 }
797 
798 /**
799  * @tc.name: OnDeviceOffline002
800  * @tc.desc: test OnDeviceOffline
801  * @tc.type: FUNC
802  */
HWTEST(HwCastSupplementTest, OnDeviceOffline002, TestSize.Level1)803 static HWTEST(HwCastSupplementTest, OnDeviceOffline002, TestSize.Level1)
804 {
805     SLOGI("OnLogEvent002 begin!");
806     std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
807     EXPECT_EQ(hwCastProvider != nullptr, true);
808     hwCastProvider->Init();
809 
810     std::shared_ptr<AVCastProviderManager> ptr = std::make_shared<AVCastProviderManager>();
811     hwCastProvider->castStateListenerList_.push_back(ptr);
812 
813     std::string deviceId = "111";
814     hwCastProvider->OnDeviceOffline(deviceId);
815     SLOGI("OnDeviceOffline002 end!");
816 }
817 
818 /**
819  * @tc.name: OnServiceDied001
820  * @tc.desc: test OnServiceDied
821  * @tc.type: FUNC
822  * @tc.require:
823  */
HWTEST(HwCastSupplementTest, OnServiceDied001, TestSize.Level1)824 static HWTEST(HwCastSupplementTest, OnServiceDied001, TestSize.Level1)
825 {
826     SLOGI("OnServiceDied001 begin!");
827     std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
828     EXPECT_EQ(hwCastProvider != nullptr, true);
829     hwCastProvider->Init();
830 
831     std::shared_ptr<AVCastProviderManager> ptr = std::make_shared<AVCastProviderManager>();
832     hwCastProvider->castStateListenerList_.push_back(ptr);
833     hwCastProvider->OnServiceDied();
834     SLOGI("OnServiceDied001 end!");
835 }
836 
837 } // OHOS::AVSession