1 /*
2  * Copyright (c) 2023 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 "avsession_errors.h"
18 #include "avsession_log.h"
19 #include "hw_cast_stream_player.h"
20 #include "hw_cast_provider.h"
21 
22 using namespace testing::ext;
23 using namespace OHOS::AVSession;
24 
25 class HwCastTest : public testing::Test {
26 public:
27     static void SetUpTestCase(void);
28     static void TearDownTestCase(void);
29     void SetUp();
30     void TearDown();
31 };
32 
SetUpTestCase()33 void HwCastTest::SetUpTestCase()
34 {}
35 
TearDownTestCase()36 void HwCastTest::TearDownTestCase()
37 {}
38 
SetUp()39 void HwCastTest::SetUp()
40 {}
41 
TearDown()42 void HwCastTest::TearDown()
43 {}
44 
45 /**
46  * @tc.name: HwCastStreamPlayerInit001
47  * @tc.desc:
48  * @tc.type: FUNC
49  * @tc.require:
50  */
51 static HWTEST(HwCastTest, HwCastStreamPlayerInit001, TestSize.Level1)
52 {
53     SLOGI("HwCastStreamPlayerInit001 begin!");
54     std::shared_ptr<HwCastStreamPlayer> streamplayer = std::make_shared<HwCastStreamPlayer>(nullptr);
55     EXPECT_EQ(streamplayer != nullptr, true);
56     streamplayer->Init();
57     SLOGI("HwCastStreamPlayerInit001 end!");
58 }
59 
60 /**
61  * @tc.name: HwCastStreamPlayerRelease001
62  * @tc.desc:
63  * @tc.type: FUNC
64  * @tc.require:
65  */
66 static HWTEST(HwCastTest, HwCastStreamPlayerRelease001, TestSize.Level1)
67 {
68     SLOGI("HwCastStreamPlayerRelease001 begin!");
69     std::shared_ptr<HwCastStreamPlayer> streamplayer = std::make_shared<HwCastStreamPlayer>(nullptr);
70     EXPECT_EQ(streamplayer != nullptr, true);
71     streamplayer->Release();
72     SLOGI("HwCastStreamPlayerRelease001 end!");
73 }
74 
75 /**
76  * @tc.name: HwCastStreamPlayerSendControlCommand001
77  * @tc.desc: cmd : CAST_CONTROL_CMD_INVALID
78  * @tc.type: FUNC
79  * @tc.require:
80  */
81 static HWTEST(HwCastTest, HwCastStreamPlayerSendControlCommand001, TestSize.Level1)
82 {
83     SLOGI("HwCastStreamPlayerSendControlCommand001 begin!");
84     std::shared_ptr<HwCastStreamPlayer> streamplayer = std::make_shared<HwCastStreamPlayer>(nullptr);
85     EXPECT_EQ(streamplayer != nullptr, true);
86     streamplayer->Init();
87     AVCastControlCommand cmd;
88     cmd.SetCommand(OHOS::AVSession::AVCastControlCommand::CAST_CONTROL_CMD_INVALID);
89     streamplayer->SendControlCommand(cmd);
90     SLOGI("HwCastStreamPlayerSendControlCommand001 end!");
91 }
92 
93 /**
94  * @tc.name: HwCastStreamPlayerSendControlCommand002
95  * @tc.desc: cmd : CAST_CONTROL_CMD_PLAY
96  * @tc.type: FUNC
97  * @tc.require:
98  */
99 static HWTEST(HwCastTest, HwCastStreamPlayerSendControlCommand002, TestSize.Level1)
100 {
101     SLOGI("HwCastStreamPlayerSendControlCommand002 begin!");
102     std::shared_ptr<HwCastStreamPlayer> streamplayer = std::make_shared<HwCastStreamPlayer>(nullptr);
103     EXPECT_EQ(streamplayer != nullptr, true);
104     streamplayer->Init();
105     AVCastControlCommand cmd;
106     cmd.SetCommand(OHOS::AVSession::AVCastControlCommand::CAST_CONTROL_CMD_PLAY);
107     streamplayer->SendControlCommand(cmd);
108     SLOGI("HwCastStreamPlayerSendControlCommand002 end!");
109 }
110 
111 /**
112  * @tc.name: HwCastStreamPlayerSendControlCommand003
113  * @tc.desc: cmd : CAST_CONTROL_CMD_PAUSE
114  * @tc.type: FUNC
115  * @tc.require:
116  */
117 static HWTEST(HwCastTest, HwCastStreamPlayerSendControlCommand003, TestSize.Level1)
118 {
119     SLOGI("HwCastStreamPlayerSendControlCommand003 begin!");
120     std::shared_ptr<HwCastStreamPlayer> streamplayer = std::make_shared<HwCastStreamPlayer>(nullptr);
121     EXPECT_EQ(streamplayer != nullptr, true);
122     streamplayer->Init();
123     AVCastControlCommand cmd;
124     cmd.SetCommand(OHOS::AVSession::AVCastControlCommand::CAST_CONTROL_CMD_PAUSE);
125     streamplayer->SendControlCommand(cmd);
126     SLOGI("HwCastStreamPlayerSendControlCommand003 end!");
127 }
128 
129 /**
130  * @tc.name: HwCastStreamPlayerSendControlCommand004
131  * @tc.desc: cmd : CAST_CONTROL_CMD_STOP
132  * @tc.type: FUNC
133  * @tc.require:
134  */
135 static HWTEST(HwCastTest, HwCastStreamPlayerSendControlCommand004, TestSize.Level1)
136 {
137     SLOGI("HwCastStreamPlayerSendControlCommand004 begin!");
138     std::shared_ptr<HwCastStreamPlayer> streamplayer = std::make_shared<HwCastStreamPlayer>(nullptr);
139     EXPECT_EQ(streamplayer != nullptr, true);
140     streamplayer->Init();
141     AVCastControlCommand cmd;
142     cmd.SetCommand(OHOS::AVSession::AVCastControlCommand::CAST_CONTROL_CMD_STOP);
143     streamplayer->SendControlCommand(cmd);
144     SLOGI("HwCastStreamPlayerSendControlCommand004 end!");
145 }
146 
147 /**
148  * @tc.name: HwCastStreamPlayerSendControlCommand005
149  * @tc.desc: cmd : CAST_CONTROL_CMD_PLAY_NEXT
150  * @tc.type: FUNC
151  * @tc.require:
152  */
153 static HWTEST(HwCastTest, HwCastStreamPlayerSendControlCommand005, TestSize.Level1)
154 {
155     SLOGI("HwCastStreamPlayerSendControlCommand005 begin!");
156     std::shared_ptr<HwCastStreamPlayer> streamplayer = std::make_shared<HwCastStreamPlayer>(nullptr);
157     EXPECT_EQ(streamplayer != nullptr, true);
158     streamplayer->Init();
159     AVCastControlCommand cmd;
160     cmd.SetCommand(OHOS::AVSession::AVCastControlCommand::CAST_CONTROL_CMD_PLAY_NEXT);
161     streamplayer->SendControlCommand(cmd);
162     SLOGI("HwCastStreamPlayerSendControlCommand005 end!");
163 }
164 
165 /**
166  * @tc.name: HwCastStreamPlayerSendControlCommand006
167  * @tc.desc: cmd : CAST_CONTROL_CMD_PLAY_PREVIOUS
168  * @tc.type: FUNC
169  * @tc.require:
170  */
171 static HWTEST(HwCastTest, HwCastStreamPlayerSendControlCommand006, TestSize.Level1)
172 {
173     SLOGI("HwCastStreamPlayerSendControlCommand006 begin!");
174     std::shared_ptr<HwCastStreamPlayer> streamplayer = std::make_shared<HwCastStreamPlayer>(nullptr);
175     EXPECT_EQ(streamplayer != nullptr, true);
176     streamplayer->Init();
177     AVCastControlCommand cmd;
178     cmd.SetCommand(OHOS::AVSession::AVCastControlCommand::CAST_CONTROL_CMD_PLAY_PREVIOUS);
179     streamplayer->SendControlCommand(cmd);
180     SLOGI("HwCastStreamPlayerSendControlCommand006 end!");
181 }
182 
183 /**
184  * @tc.name: HwCastStreamPlayerGetCurrentItem001
185  * @tc.desc:
186  * @tc.type: FUNC
187  * @tc.require:
188  */
189 static HWTEST(HwCastTest, HwCastStreamPlayerGetCurrentItem001, TestSize.Level1)
190 {
191     SLOGI("HwCastStreamPlayerGetCurrentItem001 begin!");
192     std::shared_ptr<HwCastStreamPlayer> streamplayer = std::make_shared<HwCastStreamPlayer>(nullptr);
193     EXPECT_EQ(streamplayer != nullptr, true);
194     streamplayer->Init();
195     AVQueueItem item = streamplayer->GetCurrentItem();
196     SLOGI("HwCastStreamPlayerGetCurrentItem001 end!");
197 }
198 
199 /**
200  * @tc.name: HwCastStreamPlayerStart001
201  * @tc.desc:
202  * @tc.type: FUNC
203  * @tc.require:
204  */
205 static HWTEST(HwCastTest, HwCastStreamPlayerStart001, TestSize.Level1)
206 {
207     SLOGI("HwCastStreamPlayerStart001 begin!");
208     std::shared_ptr<HwCastStreamPlayer> streamplayer = std::make_shared<HwCastStreamPlayer>(nullptr);
209     EXPECT_EQ(streamplayer != nullptr, true);
210     streamplayer->Init();
211     AVQueueItem item;
212     std::shared_ptr<AVMediaDescription> description = std::make_shared<AVMediaDescription>();
213     description->SetMediaId("123");
214     description->SetTitle("Title");
215     description->SetSubtitle("Subtitle");
216     description->SetDescription("This is music description");
217     description->SetIcon(nullptr);
218     description->SetIconUri("xxxxx");
219     description->SetExtras(nullptr);
220     description->SetMediaUri("Media url");
221     item.SetDescription(description);
222     int32_t ret = streamplayer->Start(item);
223     EXPECT_EQ(ret, AVSESSION_ERROR);
224     SLOGI("HwCastStreamPlayerStart001 end!");
225 }
226 
227 /**
228  * @tc.name: HwCastStreamPlayerPrepare001
229  * @tc.desc:
230  * @tc.type: FUNC
231  * @tc.require:
232  */
233 static HWTEST(HwCastTest, HwCastStreamPlayerPrepare001, TestSize.Level1)
234 {
235     SLOGI("HwCastStreamPlayerPrepare001 begin!");
236     std::shared_ptr<HwCastStreamPlayer> streamplayer = std::make_shared<HwCastStreamPlayer>(nullptr);
237     EXPECT_EQ(streamplayer != nullptr, true);
238     streamplayer->Init();
239     AVQueueItem item;
240     std::shared_ptr<AVMediaDescription> description = std::make_shared<AVMediaDescription>();
241     description->SetMediaId("123");
242     description->SetTitle("Title");
243     description->SetSubtitle("Subtitle");
244     description->SetDescription("This is music description");
245     description->SetIcon(nullptr);
246     description->SetIconUri("xxxxx");
247     description->SetExtras(nullptr);
248     description->SetMediaUri("Media url");
249     item.SetDescription(description);
250     int32_t ret = streamplayer->Prepare(item);
251     EXPECT_EQ(ret, AVSESSION_ERROR);
252     SLOGI("HwCastStreamPlayerPrepare001 end!");
253 }
254 
255 /**
256  * @tc.name: HwCastStreamPlayerGetDuration001
257  * @tc.desc:
258  * @tc.type: FUNC
259  * @tc.require:
260  */
261 static HWTEST(HwCastTest, HwCastStreamPlayerGetDuration001, TestSize.Level1)
262 {
263     SLOGI("HwCastStreamPlayerGetDuration001 begin!");
264     std::shared_ptr<HwCastStreamPlayer> streamplayer = std::make_shared<HwCastStreamPlayer>(nullptr);
265     EXPECT_EQ(streamplayer != nullptr, true);
266     streamplayer->Init();
267     int32_t duration;
268     int32_t ret = streamplayer->GetDuration(duration);
269     EXPECT_EQ(ret, AVSESSION_ERROR);
270     SLOGI("HwCastStreamPlayerGetDuration001 end!");
271 }
272 
273 /**
274  * @tc.name: HwCastStreamPlayerGetCastAVPlaybackState001
275  * @tc.desc:
276  * @tc.type: FUNC
277  * @tc.require:
278  */
279 static HWTEST(HwCastTest, HwCastStreamPlayerGetCastAVPlaybackState001, TestSize.Level1)
280 {
281     SLOGI("HwCastStreamPlayerGetCastAVPlaybackState001 begin!");
282     std::shared_ptr<HwCastStreamPlayer> streamplayer = std::make_shared<HwCastStreamPlayer>(nullptr);
283     EXPECT_EQ(streamplayer != nullptr, true);
284     streamplayer->Init();
285     AVPlaybackState avPlaybackState;
286     int32_t ret = streamplayer->GetCastAVPlaybackState(avPlaybackState);
287     EXPECT_EQ(ret, AVSESSION_ERROR);
288     SLOGI("HwCastStreamPlayerGetCastAVPlaybackState001 end!");
289 }
290 
291 /**
292  * @tc.name: HwCastStreamPlayerSetDisplaySurface001
293  * @tc.desc:
294  * @tc.type: FUNC
295  * @tc.require:
296  */
297 static HWTEST(HwCastTest, HwCastStreamPlayerSetDisplaySurface001, TestSize.Level1)
298 {
299     SLOGI("HwCastStreamPlayerSetDisplaySurface001 begin!");
300     std::shared_ptr<HwCastStreamPlayer> streamplayer = std::make_shared<HwCastStreamPlayer>(nullptr);
301     EXPECT_EQ(streamplayer != nullptr, true);
302     streamplayer->Init();
303     std::string surfaceId = "surfaceId";
304     int32_t ret = streamplayer->SetDisplaySurface(surfaceId);
305     EXPECT_EQ(ret, AVSESSION_ERROR);
306     SLOGI("HwCastStreamPlayerSetDisplaySurface001 end!");
307 }
308 
309 /**
310  * @tc.name: HwCastStreamPlayerRegisterControllerListener001
311  * @tc.desc: Listener is nullptr
312  * @tc.type: FUNC
313  * @tc.require:
314  */
315 static HWTEST(HwCastTest, HwCastStreamPlayerRegisterControllerListener001, TestSize.Level1)
316 {
317     SLOGI("HwCastStreamPlayerRegisterControllerListener001 begin!");
318     std::shared_ptr<HwCastStreamPlayer> streamplayer = std::make_shared<HwCastStreamPlayer>(nullptr);
319     EXPECT_EQ(streamplayer != nullptr, true);
320     streamplayer->Init();
321     int32_t ret = streamplayer->RegisterControllerListener(nullptr);
322     EXPECT_EQ(ret, AVSESSION_ERROR);
323     SLOGI("HwCastStreamPlayerRegisterControllerListener001 end!");
324 }
325 
326 /**
327  * @tc.name: HwCastStreamPlayerUnRegisterControllerListener001
328  * @tc.desc: Listener is nullptr
329  * @tc.type: FUNC
330  * @tc.require:
331  */
332 static HWTEST(HwCastTest, HwCastStreamPlayerUnRegisterControllerListener001, TestSize.Level1)
333 {
334     SLOGI("HwCastStreamPlayerUnRegisterControllerListener001 begin!");
335     std::shared_ptr<HwCastStreamPlayer> streamplayer = std::make_shared<HwCastStreamPlayer>(nullptr);
336     EXPECT_EQ(streamplayer != nullptr, true);
337     streamplayer->Init();
338     int32_t ret = streamplayer->UnRegisterControllerListener(nullptr);
339     EXPECT_EQ(ret, AVSESSION_ERROR);
340     SLOGI("HwCastStreamPlayerUnRegisterControllerListener001 end!");
341 }
342 
343 /**
344  * @tc.name: HwCastStreamPlayerOnStateChanged001
345  * @tc.desc:
346  * @tc.type: FUNC
347  * @tc.require:
348  */
349 static HWTEST(HwCastTest, HwCastStreamPlayerOnStateChanged001, TestSize.Level1)
350 {
351     SLOGI("HwCastStreamPlayerOnStateChanged001 begin!");
352     std::shared_ptr<HwCastStreamPlayer> streamplayer = std::make_shared<HwCastStreamPlayer>(nullptr);
353     EXPECT_EQ(streamplayer != nullptr, true);
354     streamplayer->Init();
355     OHOS::CastEngine::PlayerStates playbackState = OHOS::CastEngine::PlayerStates::PLAYER_STATE_ERROR;
356     streamplayer->OnStateChanged(playbackState, true);
357     SLOGI("HwCastStreamPlayerOnStateChanged001 end!");
358 }
359 
360 /**
361  * @tc.name: HwCastStreamPlayerOnPositionChanged001
362  * @tc.desc:
363  * @tc.type: FUNC
364  * @tc.require:
365  */
366 static HWTEST(HwCastTest, HwCastStreamPlayerOnPositionChanged001, TestSize.Level1)
367 {
368     SLOGI("HwCastStreamPlayerOnPositionChanged001 begin!");
369     std::shared_ptr<HwCastStreamPlayer> streamplayer = std::make_shared<HwCastStreamPlayer>(nullptr);
370     EXPECT_EQ(streamplayer != nullptr, true);
371     streamplayer->Init();
372     int position = 0;
373     int bufferPosition = 0;
374     int duration = 0;
375     streamplayer->OnPositionChanged(position, bufferPosition, duration);
376     SLOGI("HwCastStreamPlayerOnPositionChanged001 end!");
377 }
378 
379 /**
380  * @tc.name: HwCastStreamPlayerOnPositionChanged002
381  * @tc.desc:
382  * @tc.type: FUNC
383  * @tc.require:
384  */
385 static HWTEST(HwCastTest, HwCastStreamPlayerOnPositionChanged002, TestSize.Level1)
386 {
387     SLOGI("HwCastStreamPlayerOnPositionChanged002 begin!");
388     std::shared_ptr<HwCastStreamPlayer> streamplayer = std::make_shared<HwCastStreamPlayer>(nullptr);
389     EXPECT_EQ(streamplayer != nullptr, true);
390     streamplayer->Init();
391     int position = -1;
392     int bufferPosition = 0;
393     int duration = 0;
394     streamplayer->OnPositionChanged(position, bufferPosition, duration);
395     SLOGI("HwCastStreamPlayerOnPositionChanged002 end!");
396 }
397 
398 /**
399  * @tc.name: HwCastStreamPlayerOnPositionChanged003
400  * @tc.desc:
401  * @tc.type: FUNC
402  * @tc.require:
403  */
404 static HWTEST(HwCastTest, HwCastStreamPlayerOnPositionChanged003, TestSize.Level1)
405 {
406     SLOGI("HwCastStreamPlayerOnPositionChanged003 begin!");
407     std::shared_ptr<HwCastStreamPlayer> streamplayer = std::make_shared<HwCastStreamPlayer>(nullptr);
408     EXPECT_EQ(streamplayer != nullptr, true);
409     streamplayer->Init();
410     int position = 0;
411     int bufferPosition = -1;
412     int duration = 0;
413     streamplayer->OnPositionChanged(position, bufferPosition, duration);
414     SLOGI("HwCastStreamPlayerOnPositionChanged003 end!");
415 }
416 
417 /**
418  * @tc.name: HwCastStreamPlayerOnPositionChanged004
419  * @tc.desc:
420  * @tc.type: FUNC
421  * @tc.require:
422  */
423 static HWTEST(HwCastTest, HwCastStreamPlayerOnPositionChanged004, TestSize.Level1)
424 {
425     SLOGI("HwCastStreamPlayerOnPositionChanged004 begin!");
426     std::shared_ptr<HwCastStreamPlayer> streamplayer = std::make_shared<HwCastStreamPlayer>(nullptr);
427     EXPECT_EQ(streamplayer != nullptr, true);
428     streamplayer->Init();
429     int position = -1;
430     int bufferPosition = -1;
431     int duration = 0;
432     streamplayer->OnPositionChanged(position, bufferPosition, duration);
433     SLOGI("HwCastStreamPlayerOnPositionChanged004 end!");
434 }
435 
436 /**
437  * @tc.name: HwCastStreamPlayerOnMediaItemChanged001
438  * @tc.desc:
439  * @tc.type: FUNC
440  * @tc.require:
441  */
442 static HWTEST(HwCastTest, HwCastStreamPlayerOnMediaItemChanged001, TestSize.Level1)
443 {
444     SLOGI("HwCastStreamPlayerOnMediaItemChanged001 begin!");
445     std::shared_ptr<HwCastStreamPlayer> streamplayer = std::make_shared<HwCastStreamPlayer>(nullptr);
446     EXPECT_EQ(streamplayer != nullptr, true);
447     streamplayer->Init();
448     OHOS::CastEngine::MediaInfo mediaInfo;
449     streamplayer->OnMediaItemChanged(mediaInfo);
450     SLOGI("HwCastStreamPlayerOnMediaItemChanged001 end!");
451 }
452 
453 /**
454  * @tc.name: HwCastStreamPlayerOnVolumeChanged001
455  * @tc.desc:
456  * @tc.type: FUNC
457  * @tc.require:
458  */
459 static HWTEST(HwCastTest, HwCastStreamPlayerOnVolumeChanged001, TestSize.Level1)
460 {
461     SLOGI("HwCastStreamPlayerOnVolumeChanged001 begin!");
462     std::shared_ptr<HwCastStreamPlayer> streamplayer = std::make_shared<HwCastStreamPlayer>(nullptr);
463     EXPECT_EQ(streamplayer != nullptr, true);
464     streamplayer->Init();
465     int volume = 0;
466     int maxVolume = 0;
467     streamplayer->OnVolumeChanged(volume, maxVolume);
468     SLOGI("HwCastStreamPlayerOnVolumeChanged001 end!");
469 }
470 
471 /**
472  * @tc.name: HwCastStreamPlayerOnLoopModeChanged001
473  * @tc.desc:
474  * @tc.type: FUNC
475  * @tc.require:
476  */
477 static HWTEST(HwCastTest, HwCastStreamPlayerOnLoopModeChanged001, TestSize.Level1)
478 {
479     SLOGI("HwCastStreamPlayerOnLoopModeChanged001 begin!");
480     std::shared_ptr<HwCastStreamPlayer> streamplayer = std::make_shared<HwCastStreamPlayer>(nullptr);
481     EXPECT_EQ(streamplayer != nullptr, true);
482     streamplayer->Init();
483     OHOS::CastEngine::LoopMode loopMode = OHOS::CastEngine::LoopMode::LOOP_MODE_SINGLE;
484     streamplayer->OnLoopModeChanged(loopMode);
485     SLOGI("HwCastStreamPlayerOnLoopModeChanged001 end!");
486 }
487 
488 /**
489  * @tc.name: HwCastStreamPlayerOnNextRequest001
490  * @tc.desc:
491  * @tc.type: FUNC
492  * @tc.require:
493  */
494 static HWTEST(HwCastTest, HwCastStreamPlayerOnNextRequest001, TestSize.Level1)
495 {
496     SLOGI("HwCastStreamPlayerOnNextRequest001 begin!");
497     std::shared_ptr<HwCastStreamPlayer> streamplayer = std::make_shared<HwCastStreamPlayer>(nullptr);
498     EXPECT_EQ(streamplayer != nullptr, true);
499     streamplayer->Init();
500     streamplayer->OnNextRequest();
501     SLOGI("HwCastStreamPlayerOnNextRequest001 end!");
502 }
503 
504 /**
505  * @tc.name: HwCastStreamPlayerOnPreviousRequest001
506  * @tc.desc:
507  * @tc.type: FUNC
508  * @tc.require:
509  */
510 static HWTEST(HwCastTest, HwCastStreamPlayerOnPreviousRequest001, TestSize.Level1)
511 {
512     SLOGI("HwCastStreamPlayerOnPreviousRequest001 begin!");
513     std::shared_ptr<HwCastStreamPlayer> streamplayer = std::make_shared<HwCastStreamPlayer>(nullptr);
514     EXPECT_EQ(streamplayer != nullptr, true);
515     streamplayer->Init();
516     streamplayer->OnPreviousRequest();
517     SLOGI("HwCastStreamPlayerOnPreviousRequest001 end!");
518 }
519 
520 /**
521  * @tc.name: HwCastStreamPlayerOnPlaySpeedChanged001
522  * @tc.desc:
523  * @tc.type: FUNC
524  * @tc.require:
525  */
526 static HWTEST(HwCastTest, HwCastStreamPlayerOnPlaySpeedChanged001, TestSize.Level1)
527 {
528     SLOGI("HwCastStreamPlayerOnPlaySpeedChanged001 begin!");
529     std::shared_ptr<HwCastStreamPlayer> streamplayer = std::make_shared<HwCastStreamPlayer>(nullptr);
530     EXPECT_EQ(streamplayer != nullptr, true);
531     streamplayer->Init();
532     OHOS::CastEngine::PlaybackSpeed speed = OHOS::CastEngine::PlaybackSpeed::SPEED_FORWARD_1_00_X;
533     streamplayer->OnPlaySpeedChanged(speed);
534     SLOGI("HwCastStreamPlayerOnPlaySpeedChanged001 end!");
535 }
536 
537 /**
538  * @tc.name: HwCastStreamPlayerOnPlayerError001
539  * @tc.desc:
540  * @tc.type: FUNC
541  * @tc.require:
542  */
543 static HWTEST(HwCastTest, HwCastStreamPlayerOnPlayerError001, TestSize.Level1)
544 {
545     SLOGI("HwCastStreamPlayerOnPlayerError001 begin!");
546     std::shared_ptr<HwCastStreamPlayer> streamplayer = std::make_shared<HwCastStreamPlayer>(nullptr);
547     EXPECT_EQ(streamplayer != nullptr, true);
548     streamplayer->Init();
549     int errorCode = 0;
550     std::string errorMsg = "errorMsg";
551     streamplayer->OnPlayerError(errorCode, errorMsg);
552     SLOGI("HwCastStreamPlayerOnPlayerError001 end!");
553 }
554 
555 /**
556  * @tc.name: HwCastStreamPlayerOnSeekDone001
557  * @tc.desc:
558  * @tc.type: FUNC
559  * @tc.require:
560  */
561 static HWTEST(HwCastTest, HwCastStreamPlayerOnSeekDone001, TestSize.Level1)
562 {
563     SLOGI("HwCastStreamPlayerOnSeekDone001 begin!");
564     std::shared_ptr<HwCastStreamPlayer> streamplayer = std::make_shared<HwCastStreamPlayer>(nullptr);
565     EXPECT_EQ(streamplayer != nullptr, true);
566     streamplayer->Init();
567     int32_t seekDone = 0;
568     streamplayer->OnSeekDone(seekDone);
569     SLOGI("HwCastStreamPlayerOnSeekDone001 end!");
570 }
571 
572 /**
573  * @tc.name: HwCastStreamPlayerOnVideoSizeChanged001
574  * @tc.desc:
575  * @tc.type: FUNC
576  * @tc.require:
577  */
578 static HWTEST(HwCastTest, HwCastStreamPlayerOnVideoSizeChanged001, TestSize.Level1)
579 {
580     SLOGI("HwCastStreamPlayerOnVideoSizeChanged001 begin!");
581     std::shared_ptr<HwCastStreamPlayer> streamplayer = std::make_shared<HwCastStreamPlayer>(nullptr);
582     EXPECT_EQ(streamplayer != nullptr, true);
583     streamplayer->Init();
584     int32_t width = 0;
585     int32_t height = 0;
586     streamplayer->OnVideoSizeChanged(width, height);
587     SLOGI("HwCastStreamPlayerOnVideoSizeChanged001 end!");
588 }
589 
590 /**
591  * @tc.name: HwCastStreamPlayerOnEndOfStream001
592  * @tc.desc:
593  * @tc.type: FUNC
594  * @tc.require:
595  */
596 static HWTEST(HwCastTest, HwCastStreamPlayerOnEndOfStream001, TestSize.Level1)
597 {
598     SLOGI("HwCastStreamPlayerOnEndOfStream001 begin!");
599     std::shared_ptr<HwCastStreamPlayer> streamplayer = std::make_shared<HwCastStreamPlayer>(nullptr);
600     EXPECT_EQ(streamplayer != nullptr, true);
601     streamplayer->Init();
602     int32_t isLooping = 0;
603     streamplayer->OnEndOfStream(isLooping);
604     SLOGI("HwCastStreamPlayerOnEndOfStream001 end!");
605 }
606 
607 /**
608  * @tc.name: HwCastStreamPlayerOnPlayRequest001
609  * @tc.desc:
610  * @tc.type: FUNC
611  * @tc.require:
612  */
613 static HWTEST(HwCastTest, HwCastStreamPlayerOnPlayRequest001, TestSize.Level1)
614 {
615     SLOGI("HwCastStreamPlayerOnPlayRequest001 begin!");
616     std::shared_ptr<HwCastStreamPlayer> streamplayer = std::make_shared<HwCastStreamPlayer>(nullptr);
617     EXPECT_EQ(streamplayer != nullptr, true);
618     streamplayer->Init();
619     OHOS::CastEngine::MediaInfo mediaInfo;
620     streamplayer->OnPlayRequest(mediaInfo);
621     SLOGI("HwCastStreamPlayerOnPlayRequest001 end!");
622 }
623 
624 /**
625  * @tc.name: HwCastStreamPlayerOnKeyRequest001
626  * @tc.desc:
627  * @tc.type: FUNC
628  * @tc.require:
629  */
630 static HWTEST(HwCastTest, HwCastStreamPlayerOnKeyRequest001, TestSize.Level1)
631 {
632     SLOGI("HwCastStreamPlayerOnKeyRequest001 begin!");
633     std::shared_ptr<HwCastStreamPlayer> streamplayer = std::make_shared<HwCastStreamPlayer>(nullptr);
634     EXPECT_EQ(streamplayer != nullptr, true);
635     streamplayer->Init();
636     std::string assetId = "assetId";
637     std::vector<uint8_t> keyRequestData;
638     streamplayer->OnKeyRequest(assetId, keyRequestData);
639     SLOGI("HwCastStreamPlayerOnKeyRequest001 end!");
640 }
641 
642 class StreamPlayerImpl : public OHOS::CastEngine::IStreamPlayer {
643 public:
GetPosition(int32_t & currentPosition)644     int GetPosition(int32_t& currentPosition) override
645     {
646         return 0;
647     };
648 
Seek(int32_t position)649     int Seek(int32_t position) override
650     {
651         return 0;
652     };
653 
SetSpeed(const OHOS::CastEngine::PlaybackSpeed speed)654     int SetSpeed(const OHOS::CastEngine::PlaybackSpeed speed) override
655     {
656         return 0;
657     };
658 
FastForward(const int32_t delta)659     int FastForward(const int32_t delta) override
660     {
661         return 0;
662     };
663 
FastRewind(const int32_t delta)664     int FastRewind(const int32_t delta) override
665     {
666         return 0;
667     };
668 
SetVolume(const int32_t volume)669     int SetVolume(const int32_t volume) override
670     {
671         return 0;
672     };
673 
SetMute(bool mute)674     int SetMute(bool mute) override
675     {
676         return 0;
677     };
678 
ProvideKeyResponse(const std::string & mediaId,const std::vector<uint8_t> & response)679     int ProvideKeyResponse(const std::string &mediaId, const std::vector<uint8_t> &response) override
680     {
681         return 0;
682     };
683 
SetLoopMode(const OHOS::CastEngine::LoopMode loopMode)684     int SetLoopMode(const OHOS::CastEngine::LoopMode loopMode) override
685     {
686         return 0;
687     };
688 
RegisterListener(std::shared_ptr<OHOS::CastEngine::IStreamPlayerListener> listener)689     int RegisterListener(std::shared_ptr<OHOS::CastEngine::IStreamPlayerListener> listener) override
690     {
691         return 0;
692     };
693 
UnregisterListener()694     int UnregisterListener() override
695     {
696         return 0;
697     };
698 
SetSurface(const std::string & surfaceInfo)699     int SetSurface(const std::string &surfaceInfo) override
700     {
701         return 0;
702     };
703 
Load(const OHOS::CastEngine::MediaInfo & media)704     int Load(const OHOS::CastEngine::MediaInfo &media) override
705     {
706         return 0;
707     };
708 
Play()709     int Play() override
710     {
711         return 0;
712     };
713 
Play(const OHOS::CastEngine::MediaInfo & media)714     int Play(const OHOS::CastEngine::MediaInfo &media) override
715     {
716         return 0;
717     };
718 
Play(int index)719     int Play(int index) override
720     {
721         return 0;
722     };
723 
Pause()724     int Pause() override
725     {
726         return 0;
727     };
Stop()728     int Stop() override
729     {
730         return 0;
731     };
Next()732     int Next() override
733     {
734         return 0;
735     };
736 
Previous()737     int Previous() override
738     {
739         return 0;
740     };
741 
GetPlayerStatus(OHOS::CastEngine::PlayerStates & status)742     int GetPlayerStatus(OHOS::CastEngine::PlayerStates &status) override
743     {
744         return 0;
745     };
746 
GetDuration(int & duration)747     int GetDuration(int &duration) override
748     {
749         return 0;
750     };
751 
GetVolume(int32_t & volume,int32_t & maxVolume)752     int GetVolume(int32_t &volume, int32_t &maxVolume) override
753     {
754         return 0;
755     };
756 
GetMute(bool & mute)757     int GetMute(bool &mute) override
758     {
759         return 0;
760     };
761 
GetLoopMode(OHOS::CastEngine::LoopMode & loopMode)762     int GetLoopMode(OHOS::CastEngine::LoopMode &loopMode) override
763     {
764         return 0;
765     };
766 
GetPlaySpeed(OHOS::CastEngine::PlaybackSpeed & speed)767     int GetPlaySpeed(OHOS::CastEngine::PlaybackSpeed &speed) override
768     {
769         return 0;
770     };
771 
GetMediaInfoHolder(OHOS::CastEngine::MediaInfoHolder & hold)772     int GetMediaInfoHolder(OHOS::CastEngine::MediaInfoHolder &hold) override
773     {
774         return 0;
775     };
776 
SetAvailableCapability(const OHOS::CastEngine::StreamCapability & streamCapability)777     int SetAvailableCapability(const OHOS::CastEngine::StreamCapability &streamCapability) override
778     {
779         return 0;
780     }
781 
GetAvailableCapability(OHOS::CastEngine::StreamCapability & streamCapability)782     int GetAvailableCapability(OHOS::CastEngine::StreamCapability &streamCapability) override
783     {
784         return 0;
785     }
786 
Release()787     int Release() override
788     {
789         return 0;
790     };
791 };
792 
793 /**
794  * @tc.name: HwCastStreamPlayerSendControlCommandWithParams001
795  * @tc.desc: cmd : CAST_CONTROL_CMD_FAST_FORWARD
796  * @tc.type: FUNC
797  * @tc.require:
798  */
799 static HWTEST(HwCastTest, HwCastStreamPlayerSendControlCommandWithParams001, TestSize.Level1)
800 {
801     SLOGI("HwCastStreamPlayerSendControlCommandWithParams001 begin!");
802     std::shared_ptr<StreamPlayerImpl> player = std::make_shared<StreamPlayerImpl>();
803     std::shared_ptr<HwCastStreamPlayer> streamplayer = std::make_shared<HwCastStreamPlayer>(player);
804     EXPECT_EQ(streamplayer != nullptr, true);
805     streamplayer->Init();
806     AVCastControlCommand cmd;
807     cmd.SetCommand(OHOS::AVSession::AVCastControlCommand::CAST_CONTROL_CMD_FAST_FORWARD);
808     streamplayer->SendControlCommandWithParams(cmd);
809     SLOGI("HwCastStreamPlayerSendControlCommandWithParams001 end!");
810 }
811 
812 /**
813  * @tc.name: HwCastStreamPlayerSendControlCommandWithParams002
814  * @tc.desc: cmd : CAST_CONTROL_CMD_REWIND
815  * @tc.type: FUNC
816  * @tc.require:
817  */
818 static HWTEST(HwCastTest, HwCastStreamPlayerSendControlCommandWithParams002, TestSize.Level1)
819 {
820     SLOGI("HwCastStreamPlayerSendControlCommandWithParams002 begin!");
821     std::shared_ptr<StreamPlayerImpl> player = std::make_shared<StreamPlayerImpl>();
822     std::shared_ptr<HwCastStreamPlayer> streamplayer = std::make_shared<HwCastStreamPlayer>(player);
823     EXPECT_EQ(streamplayer != nullptr, true);
824     streamplayer->Init();
825     AVCastControlCommand cmd;
826     cmd.SetCommand(OHOS::AVSession::AVCastControlCommand::CAST_CONTROL_CMD_REWIND);
827     streamplayer->SendControlCommandWithParams(cmd);
828     SLOGI("HwCastStreamPlayerSendControlCommandWithParams002 end!");
829 }
830 
831 /**
832  * @tc.name: HwCastStreamPlayerSendControlCommandWithParams003
833  * @tc.desc: cmd : CAST_CONTROL_CMD_SEEK
834  * @tc.type: FUNC
835  * @tc.require:
836  */
837 static HWTEST(HwCastTest, HwCastStreamPlayerSendControlCommandWithParams003, TestSize.Level1)
838 {
839     SLOGI("HwCastStreamPlayerSendControlCommandWithParams003 begin!");
840     std::shared_ptr<StreamPlayerImpl> player = std::make_shared<StreamPlayerImpl>();
841     std::shared_ptr<HwCastStreamPlayer> streamplayer = std::make_shared<HwCastStreamPlayer>(player);
842     EXPECT_EQ(streamplayer != nullptr, true);
843     streamplayer->Init();
844     AVCastControlCommand cmd;
845     cmd.SetCommand(OHOS::AVSession::AVCastControlCommand::CAST_CONTROL_CMD_SEEK);
846     streamplayer->SendControlCommandWithParams(cmd);
847     SLOGI("HwCastStreamPlayerSendControlCommandWithParams003 end!");
848 }
849 
850 /**
851  * @tc.name: HwCastStreamPlayerSendControlCommandWithParams004
852  * @tc.desc: cmd : CAST_CONTROL_CMD_SET_VOLUME
853  * @tc.type: FUNC
854  * @tc.require:
855  */
856 static HWTEST(HwCastTest, HwCastStreamPlayerSendControlCommandWithParams004, TestSize.Level1)
857 {
858     SLOGI("HwCastStreamPlayerSendControlCommandWithParams004 begin!");
859     std::shared_ptr<StreamPlayerImpl> player = std::make_shared<StreamPlayerImpl>();
860     std::shared_ptr<HwCastStreamPlayer> streamplayer = std::make_shared<HwCastStreamPlayer>(player);
861     EXPECT_EQ(streamplayer != nullptr, true);
862     streamplayer->Init();
863     AVCastControlCommand cmd;
864     cmd.SetCommand(OHOS::AVSession::AVCastControlCommand::CAST_CONTROL_CMD_SET_VOLUME);
865     streamplayer->SendControlCommandWithParams(cmd);
866     SLOGI("HwCastStreamPlayerSendControlCommandWithParams004 end!");
867 }
868 
869 /**
870  * @tc.name: HwCastStreamPlayerSendControlCommandWithParams005
871  * @tc.desc: cmd : CAST_CONTROL_CMD_SET_SPEED
872  * @tc.type: FUNC
873  * @tc.require:
874  */
875 static HWTEST(HwCastTest, HwCastStreamPlayerSendControlCommandWithParams005, TestSize.Level1)
876 {
877     SLOGI("HwCastStreamPlayerSendControlCommandWithParams005 begin!");
878     std::shared_ptr<StreamPlayerImpl> player = std::make_shared<StreamPlayerImpl>();
879     std::shared_ptr<HwCastStreamPlayer> streamplayer = std::make_shared<HwCastStreamPlayer>(player);
880     EXPECT_EQ(streamplayer != nullptr, true);
881     streamplayer->Init();
882     AVCastControlCommand cmd;
883     cmd.SetCommand(OHOS::AVSession::AVCastControlCommand::CAST_CONTROL_CMD_SET_SPEED);
884     streamplayer->SendControlCommandWithParams(cmd);
885     SLOGI("HwCastStreamPlayerSendControlCommandWithParams005 end!");
886 }
887 
888 /**
889  * @tc.name: HwCastStreamPlayerSendControlCommandWithParams006
890  * @tc.desc: cmd : CAST_CONTROL_CMD_SET_LOOP_MODE
891  * @tc.type: FUNC
892  * @tc.require:
893  */
894 static HWTEST(HwCastTest, HwCastStreamPlayerSendControlCommandWithParams006, TestSize.Level1)
895 {
896     SLOGI("HwCastStreamPlayerSendControlCommandWithParams006 begin!");
897     std::shared_ptr<StreamPlayerImpl> player = std::make_shared<StreamPlayerImpl>();
898     std::shared_ptr<HwCastStreamPlayer> streamplayer = std::make_shared<HwCastStreamPlayer>(player);
899     EXPECT_EQ(streamplayer != nullptr, true);
900     streamplayer->Init();
901     AVCastControlCommand cmd;
902     cmd.SetCommand(OHOS::AVSession::AVCastControlCommand::CAST_CONTROL_CMD_SET_LOOP_MODE);
903     streamplayer->SendControlCommandWithParams(cmd);
904     SLOGI("HwCastStreamPlayerSendControlCommandWithParams006 end!");
905 }
906 
907 /**
908  * @tc.name: HwCastStreamPlayerSendControlCommandWithParams007
909  * @tc.desc: cmd : CAST_CONTROL_CMD_TOGGLE_FAVORITE
910  * @tc.type: FUNC
911  * @tc.require:
912  */
913 static HWTEST(HwCastTest, HwCastStreamPlayerSendControlCommandWithParams007, TestSize.Level1)
914 {
915     SLOGI("HwCastStreamPlayerSendControlCommandWithParams007 begin!");
916     std::shared_ptr<StreamPlayerImpl> player = std::make_shared<StreamPlayerImpl>();
917     std::shared_ptr<HwCastStreamPlayer> streamplayer = std::make_shared<HwCastStreamPlayer>(player);
918     EXPECT_EQ(streamplayer != nullptr, true);
919     streamplayer->Init();
920     AVCastControlCommand cmd;
921     cmd.SetCommand(OHOS::AVSession::AVCastControlCommand::CAST_CONTROL_CMD_TOGGLE_FAVORITE);
922     streamplayer->SendControlCommandWithParams(cmd);
923     SLOGI("HwCastStreamPlayerSendControlCommandWithParams007 end!");
924 }
925 
926 /**
927  * @tc.name: HwCastStreamPlayerSendControlCommandWithParams008
928  * @tc.desc: cmd : CAST_CONTROL_CMD_TOGGLE_MUTE
929  * @tc.type: FUNC
930  * @tc.require:
931  */
932 static HWTEST(HwCastTest, HwCastStreamPlayerSendControlCommandWithParams008, TestSize.Level1)
933 {
934     SLOGI("HwCastStreamPlayerSendControlCommandWithParams008 begin!");
935     std::shared_ptr<StreamPlayerImpl> player = std::make_shared<StreamPlayerImpl>();
936     std::shared_ptr<HwCastStreamPlayer> streamplayer = std::make_shared<HwCastStreamPlayer>(player);
937     EXPECT_EQ(streamplayer != nullptr, true);
938     streamplayer->Init();
939     AVCastControlCommand cmd;
940     cmd.SetCommand(OHOS::AVSession::AVCastControlCommand::CAST_CONTROL_CMD_TOGGLE_MUTE);
941     streamplayer->SendControlCommandWithParams(cmd);
942     SLOGI("HwCastStreamPlayerSendControlCommandWithParams008 end!");
943 }
944 
945 /**
946  * @tc.name: HwCastStreamPlayerSendControlCommandWithParams009
947  * @tc.desc: cmd : CAST_CONTROL_CMD_INVALID
948  * @tc.type: FUNC
949  * @tc.require:
950  */
951 static HWTEST(HwCastTest, HwCastStreamPlayerSendControlCommandWithParams009, TestSize.Level1)
952 {
953     SLOGI("HwCastStreamPlayerSendControlCommandWithParams009 begin!");
954     std::shared_ptr<StreamPlayerImpl> player = std::make_shared<StreamPlayerImpl>();
955     std::shared_ptr<HwCastStreamPlayer> streamplayer = std::make_shared<HwCastStreamPlayer>(player);
956     EXPECT_EQ(streamplayer != nullptr, true);
957     streamplayer->Init();
958     AVCastControlCommand cmd;
959     cmd.SetCommand(OHOS::AVSession::AVCastControlCommand::CAST_CONTROL_CMD_INVALID);
960     streamplayer->SendControlCommandWithParams(cmd);
961     SLOGI("HwCastStreamPlayerSendControlCommandWithParams009 end!");
962 }
963 
964 /**
965  * @tc.name: HwCastProviderInit001
966  * @tc.desc:
967  * @tc.type: FUNC
968  * @tc.require:
969  */
970 static HWTEST(HwCastTest, HwCastProviderInit001, TestSize.Level1)
971 {
972     SLOGI("HwCastProviderInit001 begin!");
973     std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
974     EXPECT_EQ(hwCastProvider != nullptr, true);
975     hwCastProvider->Init();
976     SLOGI("HwCastProviderInit001 end!");
977 }
978 
979 /**
980  * @tc.name: HwCastProviderStartDiscovery001
981  * @tc.desc:
982  * @tc.type: FUNC
983  * @tc.require:
984  */
985 static HWTEST(HwCastTest, HwCastProviderStartDiscovery001, TestSize.Level1)
986 {
987     SLOGI("HwCastProviderStartDiscovery001 begin!");
988     std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
989     EXPECT_EQ(hwCastProvider != nullptr, true);
990     hwCastProvider->Init();
991     int castCapability = 0;
992     std::vector<std::string> drmSchemes;
993     EXPECT_EQ(hwCastProvider->StartDiscovery(castCapability, drmSchemes), true);
994     SLOGI("HwCastProviderStartDiscovery001 end!");
995 }
996 
997 /**
998  * @tc.name: HwCastProviderStopDiscovery001
999  * @tc.desc:
1000  * @tc.type: FUNC
1001  * @tc.require:
1002  */
1003 static HWTEST(HwCastTest, HwCastProviderStopDiscovery001, TestSize.Level1)
1004 {
1005     SLOGI("HwCastProviderStopDiscovery001 begin!");
1006     std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
1007     EXPECT_EQ(hwCastProvider != nullptr, true);
1008     hwCastProvider->Init();
1009     hwCastProvider->StopDiscovery();
1010     SLOGI("HwCastProviderStopDiscovery001 end!");
1011 }
1012 
1013 /**
1014  * @tc.name: HwCastProviderSetDiscoverable001
1015  * @tc.desc:
1016  * @tc.type: FUNC
1017  * @tc.require:
1018  */
1019 static HWTEST(HwCastTest, HwCastProviderSetDiscoverable001, TestSize.Level1)
1020 {
1021     SLOGI("HwCastProviderSetDiscoverable001 begin!");
1022     std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
1023     EXPECT_EQ(hwCastProvider != nullptr, true);
1024     hwCastProvider->Init();
1025     bool enable = true;
1026     EXPECT_EQ(hwCastProvider->SetDiscoverable(enable), -1003);
1027     SLOGI("HwCastProviderSetDiscoverable001 end!");
1028 }
1029 
1030 /**
1031  * @tc.name: HwCastProviderRelease001
1032  * @tc.desc:
1033  * @tc.type: FUNC
1034  * @tc.require:
1035  */
1036 static HWTEST(HwCastTest, HwCastProviderRelease001, TestSize.Level1)
1037 {
1038     SLOGI("HwCastProviderRelease001 begin!");
1039     std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
1040     EXPECT_EQ(hwCastProvider != nullptr, true);
1041     hwCastProvider->Init();
1042     hwCastProvider->Release();
1043     SLOGI("HwCastProviderRelease001 end!");
1044 }
1045 
1046 /**
1047  * @tc.name: HwCastProviderStartCastSession001
1048  * @tc.desc:
1049  * @tc.type: FUNC
1050  * @tc.require:
1051  */
1052 static HWTEST(HwCastTest, HwCastProviderStartCastSession001, TestSize.Level1)
1053 {
1054     SLOGI("HwCastProviderStartCastSession001 begin!");
1055     std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
1056     EXPECT_EQ(hwCastProvider != nullptr, true);
1057     hwCastProvider->Init();
1058     EXPECT_EQ(hwCastProvider->StartCastSession(), AVSESSION_SUCCESS);
1059     SLOGI("HwCastProviderStartCastSession001 end!");
1060 }
1061 
1062 /**
1063  * @tc.name: HwCastProviderStopCastSession001
1064  * @tc.desc:
1065  * @tc.type: FUNC
1066  * @tc.require:
1067  */
1068 static HWTEST(HwCastTest, HwCastProviderStopCastSession001, TestSize.Level1)
1069 {
1070     SLOGI("HwCastProviderStopCastSession001 begin!");
1071     std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
1072     EXPECT_EQ(hwCastProvider != nullptr, true);
1073     hwCastProvider->Init();
1074     int castId = 0;
1075     hwCastProvider->StopCastSession(castId);
1076     SLOGI("HwCastProviderStopCastSession001 end!");
1077 }
1078 
1079 /**
1080  * @tc.name: HwCastProviderAddCastDevice001
1081  * @tc.desc:
1082  * @tc.type: FUNC
1083  * @tc.require:
1084  */
1085 static HWTEST(HwCastTest, HwCastProviderAddCastDevice001, TestSize.Level1)
1086 {
1087     SLOGI("HwCastProviderAddCastDevice001 begin!");
1088     std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
1089     EXPECT_EQ(hwCastProvider != nullptr, true);
1090     hwCastProvider->Init();
1091     int castId = 0;
1092     DeviceInfo deviceInfo;
1093     EXPECT_EQ(hwCastProvider->AddCastDevice(castId, deviceInfo), false);
1094     SLOGI("HwCastProviderAddCastDevice001 end!");
1095 }
1096 
1097 /**
1098  * @tc.name: HwCastProviderRemoveCastDevice001
1099  * @tc.desc:
1100  * @tc.type: FUNC
1101  * @tc.require:
1102  */
1103 static HWTEST(HwCastTest, HwCastProviderRemoveCastDevice001, TestSize.Level1)
1104 {
1105     SLOGI("HwCastProviderRemoveCastDevice001 begin!");
1106     std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
1107     EXPECT_EQ(hwCastProvider != nullptr, true);
1108     hwCastProvider->Init();
1109     int castId = 0;
1110     DeviceInfo deviceInfo;
1111     EXPECT_EQ(hwCastProvider->RemoveCastDevice(castId, deviceInfo), false);
1112     SLOGI("HwCastProviderRemoveCastDevice001 end!");
1113 }
1114 
1115 /**
1116  * @tc.name: HwCastProviderGetRemoteController001
1117  * @tc.desc:
1118  * @tc.type: FUNC
1119  * @tc.require:
1120  */
1121 static HWTEST(HwCastTest, HwCastProviderGetRemoteController001, TestSize.Level1)
1122 {
1123     SLOGI("HwCastProviderGetRemoteController001 begin!");
1124     std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
1125     EXPECT_EQ(hwCastProvider != nullptr, true);
1126     hwCastProvider->Init();
1127     int castId = 0;
1128     EXPECT_EQ(hwCastProvider->GetRemoteController(castId), nullptr);
1129     SLOGI("HwCastProviderGetRemoteController001 end!");
1130 }
1131 
1132 /**
1133  * @tc.name: HwCastProviderRegisterCastStateListener001
1134  * @tc.desc:
1135  * @tc.type: FUNC
1136  * @tc.require:
1137  */
1138 static HWTEST(HwCastTest, HwCastProviderRegisterCastStateListener001, TestSize.Level1)
1139 {
1140     SLOGI("HwCastProviderRegisterCastStateListener001 begin!");
1141     std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
1142     EXPECT_EQ(hwCastProvider != nullptr, true);
1143     hwCastProvider->Init();
1144     EXPECT_EQ(hwCastProvider->RegisterCastStateListener(nullptr), false);
1145     SLOGI("HwCastProviderRegisterCastStateListener001 end!");
1146 }
1147 
1148 /**
1149  * @tc.name: HwCastProviderUnregisterCastStateListener001
1150  * @tc.desc:
1151  * @tc.type: FUNC
1152  * @tc.require:
1153  */
1154 static HWTEST(HwCastTest, HwCastProviderUnregisterCastStateListener001, TestSize.Level1)
1155 {
1156     SLOGI("HwCastProviderUnregisterCastStateListener001 begin!");
1157     std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
1158     EXPECT_EQ(hwCastProvider != nullptr, true);
1159     hwCastProvider->Init();
1160     EXPECT_EQ(hwCastProvider->UnRegisterCastStateListener(nullptr), false);
1161     SLOGI("HwCastProviderUnregisterCastStateListener001 end!");
1162 }
1163 
1164 /**
1165  * @tc.name: HwCastProviderRegisterCastSessionStateListener001
1166  * @tc.desc:
1167  * @tc.type: FUNC
1168  * @tc.require:
1169  */
1170 static HWTEST(HwCastTest, HwCastProviderRegisterCastSessionStateListener001, TestSize.Level1)
1171 {
1172     SLOGI("HwCastProviderRegisterCastSessionStateListener001 begin!");
1173     std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
1174     EXPECT_EQ(hwCastProvider != nullptr, true);
1175     hwCastProvider->Init();
1176     int castId = 0;
1177     EXPECT_EQ(hwCastProvider->RegisterCastSessionStateListener(castId, nullptr), false);
1178     SLOGI("HwCastProviderRegisterCastSessionStateListener001 end!");
1179 }
1180 
1181 /**
1182  * @tc.name: HwCastProviderUnregisterCastSessionStateListener001
1183  * @tc.desc:
1184  * @tc.type: FUNC
1185  * @tc.require:
1186  */
1187 static HWTEST(HwCastTest, HwCastProviderUnregisterCastSessionStateListener001, TestSize.Level1)
1188 {
1189     SLOGI("HwCastProviderUnregisterCastSessionStateListener001 begin!");
1190     std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
1191     EXPECT_EQ(hwCastProvider != nullptr, true);
1192     hwCastProvider->Init();
1193     int castId = 0;
1194     EXPECT_EQ(hwCastProvider->RegisterCastSessionStateListener(castId, nullptr), false);
1195     SLOGI("HwCastProviderUnregisterCastSessionStateListener001 end!");
1196 }
1197 
1198 /**
1199  * @tc.name: HwCastProviderOnDeviceFound001
1200  * @tc.desc:
1201  * @tc.type: FUNC
1202  * @tc.require:
1203  */
1204 static HWTEST(HwCastTest, HwCastProviderOnDeviceFound001, TestSize.Level1)
1205 {
1206     SLOGI("HwCastProviderOnDeviceFound001 begin!");
1207     std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
1208     EXPECT_EQ(hwCastProvider != nullptr, true);
1209     hwCastProvider->Init();
1210     std::vector<OHOS::CastEngine::CastRemoteDevice> device;
1211     hwCastProvider->OnDeviceFound(device);
1212     SLOGI("HwCastProviderOnDeviceFound001 end!");
1213 }
1214 
1215 /**
1216  * @tc.name: HwCastProviderOnSessionCreated001
1217  * @tc.desc:
1218  * @tc.type: FUNC
1219  * @tc.require:
1220  */
1221 static HWTEST(HwCastTest, HwCastProviderOnSessionCreated001, TestSize.Level1)
1222 {
1223     SLOGI("HwCastProviderOnSessionCreated001 begin!");
1224     std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
1225     EXPECT_EQ(hwCastProvider != nullptr, true);
1226     hwCastProvider->Init();
1227     hwCastProvider->OnSessionCreated(nullptr);
1228     SLOGI("HwCastProviderOnSessionCreated001 end!");
1229 }
1230 
1231 /**
1232  * @tc.name: HwCastProviderOnServiceDied001
1233  * @tc.desc:
1234  * @tc.type: FUNC
1235  * @tc.require:
1236  */
1237 static HWTEST(HwCastTest, HwCastProviderOnServiceDied001, TestSize.Level1)
1238 {
1239     SLOGI("HwCastProviderOnServiceDied001 begin!");
1240     std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
1241     EXPECT_EQ(hwCastProvider != nullptr, true);
1242     hwCastProvider->Init();
1243     hwCastProvider->OnServiceDied();
1244     SLOGI("HwCastProviderOnServiceDied001 end!");
1245 }
1246 
1247 /**
1248  * @tc.name: HwCastProviderSessionInit001
1249  * @tc.desc:
1250  * @tc.type: FUNC
1251  * @tc.require:
1252  */
1253 static HWTEST(HwCastTest, HwCastProviderSessionInit001, TestSize.Level1)
1254 {
1255     SLOGI("HwCastProviderSessionInit001 begin!");
1256     std::shared_ptr<HwCastProviderSession> provideSession = std::make_shared<HwCastProviderSession>(nullptr);
1257     EXPECT_EQ(provideSession != nullptr, true);
1258     provideSession->Init();
1259     SLOGI("HwCastProviderSessionInit001 end!");
1260 }
1261 
1262 /**
1263  * @tc.name: HwCastProviderSessionRelease001
1264  * @tc.desc:
1265  * @tc.type: FUNC
1266  * @tc.require:
1267  */
1268 static HWTEST(HwCastTest, HwCastProviderSessionRelease001, TestSize.Level1)
1269 {
1270     SLOGI("HwCastProviderSessionRelease001 begin!");
1271     std::shared_ptr<HwCastProviderSession> provideSession = std::make_shared<HwCastProviderSession>(nullptr);
1272     EXPECT_EQ(provideSession != nullptr, true);
1273     provideSession->Init();
1274     provideSession->Release();
1275     SLOGI("HwCastProviderSessionRelease001 end!");
1276 }
1277 
1278 /**
1279  * @tc.name: HwCastProviderSessionOnDeviceState001
1280  * @tc.desc:
1281  * @tc.type: FUNC
1282  * @tc.require:
1283  */
1284 static HWTEST(HwCastTest, HwCastProviderSessionOnDeviceState001, TestSize.Level1)
1285 {
1286     SLOGI("HwCastProviderSessionOnDeviceState001 begin!");
1287     std::shared_ptr<HwCastProviderSession> provideSession = std::make_shared<HwCastProviderSession>(nullptr);
1288     EXPECT_EQ(provideSession != nullptr, true);
1289     provideSession->Init();
1290     OHOS::CastEngine::DeviceStateInfo stateInfo;
1291     stateInfo.deviceId = "testDeviceId";
1292     provideSession->OnDeviceState(stateInfo);
1293     SLOGI("HwCastProviderSessionOnDeviceState001 end!");
1294 }
1295 
1296 /**
1297  * @tc.name: HwCastProviderSessionAddDevice001
1298  * @tc.desc:
1299  * @tc.type: FUNC
1300  * @tc.require:
1301  */
1302 static HWTEST(HwCastTest, HwCastProviderSessionAddDevice001, TestSize.Level1)
1303 {
1304     SLOGI("HwCastProviderSessionAddDevice001 begin!");
1305     std::shared_ptr<HwCastProviderSession> provideSession = std::make_shared<HwCastProviderSession>(nullptr);
1306     EXPECT_EQ(provideSession != nullptr, true);
1307     provideSession->Init();
1308     std::string deviceId = "deviceId";
1309     EXPECT_EQ(provideSession->AddDevice(deviceId), false);
1310     SLOGI("HwCastProviderSessionAddDevice001 end!");
1311 }
1312 
1313 /**
1314  * @tc.name: HwCastProviderSessionRemoveDevice001
1315  * @tc.desc:
1316  * @tc.type: FUNC
1317  * @tc.require:
1318  */
1319 static HWTEST(HwCastTest, HwCastProviderSessionRemoveDevice001, TestSize.Level1)
1320 {
1321     SLOGI("HwCastProviderSessionRemoveDevice001 begin!");
1322     std::shared_ptr<HwCastProviderSession> provideSession = std::make_shared<HwCastProviderSession>(nullptr);
1323     EXPECT_EQ(provideSession != nullptr, true);
1324     provideSession->Init();
1325     std::string deviceId = "deviceId";
1326     EXPECT_EQ(provideSession->RemoveDevice(deviceId), false);
1327     SLOGI("HwCastProviderSessionRemoveDevice001 end!");
1328 }
1329 
1330 /**
1331  * @tc.name: HwCastProviderSessionCreateStreamPlayer001
1332  * @tc.desc:
1333  * @tc.type: FUNC
1334  * @tc.require:
1335  */
1336 static HWTEST(HwCastTest, HwCastProviderSessionCreateStreamPlayer001, TestSize.Level1)
1337 {
1338     SLOGI("HwCastProviderSessionCreateStreamPlayer001 begin!");
1339     std::shared_ptr<HwCastProviderSession> provideSession = std::make_shared<HwCastProviderSession>(nullptr);
1340     EXPECT_EQ(provideSession != nullptr, true);
1341     provideSession->Init();
1342     EXPECT_EQ(provideSession->CreateStreamPlayer(), nullptr);
1343     SLOGI("HwCastProviderSessionCreateStreamPlayer001 end!");
1344 }
1345 
1346 /**
1347  * @tc.name: HwCastProviderSessionRegisterCastSessionStateListener001
1348  * @tc.desc:
1349  * @tc.type: FUNC
1350  * @tc.require:
1351  */
1352 static HWTEST(HwCastTest, HwCastProviderSessionRegisterCastSessionStateListener001, TestSize.Level1)
1353 {
1354     SLOGI("HwCastProviderSessionRegisterCastSessionStateListener001 begin!");
1355     std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
1356     EXPECT_EQ(hwCastProvider != nullptr, true);
1357     hwCastProvider->Init();
1358     EXPECT_EQ(hwCastProvider->RegisterCastSessionStateListener(0, nullptr), false);
1359     SLOGI("HwCastProviderSessionRegisterCastSessionStateListener001 end!");
1360 }
1361 
1362 /**
1363  * @tc.name: HwCastProviderSessionUnregisterCastSessionStateListener001
1364  * @tc.desc:
1365  * @tc.type: FUNC
1366  * @tc.require:
1367  */
1368 static HWTEST(HwCastTest, HwCastProviderSessionUnregisterCastSessionStateListener001, TestSize.Level1)
1369 {
1370     SLOGI("HwCastProviderSessionUnregisterCastSessionStateListener001 begin!");
1371     std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
1372     EXPECT_EQ(hwCastProvider != nullptr, true);
1373     EXPECT_EQ(hwCastProvider->UnRegisterCastSessionStateListener(0, nullptr), false);
1374     SLOGI("HwCastProviderSessionUnregisterCastSessionStateListener001 end!");
1375 }
1376