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 streamplayer->OnVolumeChanged(volume);
467 SLOGI("HwCastStreamPlayerOnVolumeChanged001 end!");
468 }
469
470 /**
471 * @tc.name: HwCastStreamPlayerOnLoopModeChanged001
472 * @tc.desc:
473 * @tc.type: FUNC
474 * @tc.require:
475 */
476 static HWTEST(HwCastTest, HwCastStreamPlayerOnLoopModeChanged001, TestSize.Level1)
477 {
478 SLOGI("HwCastStreamPlayerOnLoopModeChanged001 begin!");
479 std::shared_ptr<HwCastStreamPlayer> streamplayer = std::make_shared<HwCastStreamPlayer>(nullptr);
480 EXPECT_EQ(streamplayer != nullptr, true);
481 streamplayer->Init();
482 OHOS::CastEngine::LoopMode loopMode = OHOS::CastEngine::LoopMode::LOOP_MODE_SINGLE;
483 streamplayer->OnLoopModeChanged(loopMode);
484 SLOGI("HwCastStreamPlayerOnLoopModeChanged001 end!");
485 }
486
487 /**
488 * @tc.name: HwCastStreamPlayerOnNextRequest001
489 * @tc.desc:
490 * @tc.type: FUNC
491 * @tc.require:
492 */
493 static HWTEST(HwCastTest, HwCastStreamPlayerOnNextRequest001, TestSize.Level1)
494 {
495 SLOGI("HwCastStreamPlayerOnNextRequest001 begin!");
496 std::shared_ptr<HwCastStreamPlayer> streamplayer = std::make_shared<HwCastStreamPlayer>(nullptr);
497 EXPECT_EQ(streamplayer != nullptr, true);
498 streamplayer->Init();
499 streamplayer->OnNextRequest();
500 SLOGI("HwCastStreamPlayerOnNextRequest001 end!");
501 }
502
503 /**
504 * @tc.name: HwCastStreamPlayerOnPreviousRequest001
505 * @tc.desc:
506 * @tc.type: FUNC
507 * @tc.require:
508 */
509 static HWTEST(HwCastTest, HwCastStreamPlayerOnPreviousRequest001, TestSize.Level1)
510 {
511 SLOGI("HwCastStreamPlayerOnPreviousRequest001 begin!");
512 std::shared_ptr<HwCastStreamPlayer> streamplayer = std::make_shared<HwCastStreamPlayer>(nullptr);
513 EXPECT_EQ(streamplayer != nullptr, true);
514 streamplayer->Init();
515 streamplayer->OnPreviousRequest();
516 SLOGI("HwCastStreamPlayerOnPreviousRequest001 end!");
517 }
518
519 /**
520 * @tc.name: HwCastStreamPlayerOnPlaySpeedChanged001
521 * @tc.desc:
522 * @tc.type: FUNC
523 * @tc.require:
524 */
525 static HWTEST(HwCastTest, HwCastStreamPlayerOnPlaySpeedChanged001, TestSize.Level1)
526 {
527 SLOGI("HwCastStreamPlayerOnPlaySpeedChanged001 begin!");
528 std::shared_ptr<HwCastStreamPlayer> streamplayer = std::make_shared<HwCastStreamPlayer>(nullptr);
529 EXPECT_EQ(streamplayer != nullptr, true);
530 streamplayer->Init();
531 OHOS::CastEngine::PlaybackSpeed speed = OHOS::CastEngine::PlaybackSpeed::SPEED_FORWARD_1_00_X;
532 streamplayer->OnPlaySpeedChanged(speed);
533 SLOGI("HwCastStreamPlayerOnPlaySpeedChanged001 end!");
534 }
535
536 /**
537 * @tc.name: HwCastStreamPlayerOnPlayerError001
538 * @tc.desc:
539 * @tc.type: FUNC
540 * @tc.require:
541 */
542 static HWTEST(HwCastTest, HwCastStreamPlayerOnPlayerError001, TestSize.Level1)
543 {
544 SLOGI("HwCastStreamPlayerOnPlayerError001 begin!");
545 std::shared_ptr<HwCastStreamPlayer> streamplayer = std::make_shared<HwCastStreamPlayer>(nullptr);
546 EXPECT_EQ(streamplayer != nullptr, true);
547 streamplayer->Init();
548 int errorCode = 0;
549 std::string errorMsg = "errorMsg";
550 streamplayer->OnPlayerError(errorCode, errorMsg);
551 SLOGI("HwCastStreamPlayerOnPlayerError001 end!");
552 }
553
554 /**
555 * @tc.name: HwCastStreamPlayerOnSeekDone001
556 * @tc.desc:
557 * @tc.type: FUNC
558 * @tc.require:
559 */
560 static HWTEST(HwCastTest, HwCastStreamPlayerOnSeekDone001, TestSize.Level1)
561 {
562 SLOGI("HwCastStreamPlayerOnSeekDone001 begin!");
563 std::shared_ptr<HwCastStreamPlayer> streamplayer = std::make_shared<HwCastStreamPlayer>(nullptr);
564 EXPECT_EQ(streamplayer != nullptr, true);
565 streamplayer->Init();
566 int32_t seekDone = 0;
567 streamplayer->OnSeekDone(seekDone);
568 SLOGI("HwCastStreamPlayerOnSeekDone001 end!");
569 }
570
571 /**
572 * @tc.name: HwCastStreamPlayerOnVideoSizeChanged001
573 * @tc.desc:
574 * @tc.type: FUNC
575 * @tc.require:
576 */
577 static HWTEST(HwCastTest, HwCastStreamPlayerOnVideoSizeChanged001, TestSize.Level1)
578 {
579 SLOGI("HwCastStreamPlayerOnVideoSizeChanged001 begin!");
580 std::shared_ptr<HwCastStreamPlayer> streamplayer = std::make_shared<HwCastStreamPlayer>(nullptr);
581 EXPECT_EQ(streamplayer != nullptr, true);
582 streamplayer->Init();
583 int32_t width = 0;
584 int32_t height = 0;
585 streamplayer->OnVideoSizeChanged(width, height);
586 SLOGI("HwCastStreamPlayerOnVideoSizeChanged001 end!");
587 }
588
589 /**
590 * @tc.name: HwCastStreamPlayerOnEndOfStream001
591 * @tc.desc:
592 * @tc.type: FUNC
593 * @tc.require:
594 */
595 static HWTEST(HwCastTest, HwCastStreamPlayerOnEndOfStream001, TestSize.Level1)
596 {
597 SLOGI("HwCastStreamPlayerOnEndOfStream001 begin!");
598 std::shared_ptr<HwCastStreamPlayer> streamplayer = std::make_shared<HwCastStreamPlayer>(nullptr);
599 EXPECT_EQ(streamplayer != nullptr, true);
600 streamplayer->Init();
601 int32_t isLooping = 0;
602 streamplayer->OnEndOfStream(isLooping);
603 SLOGI("HwCastStreamPlayerOnEndOfStream001 end!");
604 }
605
606 class StreamPlayerImpl : public OHOS::CastEngine::IStreamPlayer {
607 public:
GetPosition(int32_t & currentPosition)608 int GetPosition(int32_t& currentPosition) override
609 {
610 return 0;
611 };
612
Seek(int32_t position)613 int Seek(int32_t position) override
614 {
615 return 0;
616 };
617
SetSpeed(const OHOS::CastEngine::PlaybackSpeed speed)618 int SetSpeed(const OHOS::CastEngine::PlaybackSpeed speed) override
619 {
620 return 0;
621 };
SetVolume(const int32_t volume)622 int SetVolume(const int32_t volume) override
623 {
624 return 0;
625 };
626
SetLoopMode(const OHOS::CastEngine::LoopMode loopMode)627 int SetLoopMode(const OHOS::CastEngine::LoopMode loopMode) override
628 {
629 return 0;
630 };
631
RegisterListener(std::shared_ptr<OHOS::CastEngine::IStreamPlayerListener> listener)632 int RegisterListener(std::shared_ptr<OHOS::CastEngine::IStreamPlayerListener> listener) override
633 {
634 return 0;
635 };
636
UnregisterListener()637 int UnregisterListener() override
638 {
639 return 0;
640 };
641
SetSurface(const std::string & surfaceInfo)642 int SetSurface(const std::string &surfaceInfo) override
643 {
644 return 0;
645 };
646
Load(const OHOS::CastEngine::MediaInfo & media)647 int Load(const OHOS::CastEngine::MediaInfo &media) override
648 {
649 return 0;
650 };
651
Play()652 int Play() override
653 {
654 return 0;
655 };
656
Play(const OHOS::CastEngine::MediaInfo & media)657 int Play(const OHOS::CastEngine::MediaInfo &media) override
658 {
659 return 0;
660 };
661
Play(int index)662 int Play(int index) override
663 {
664 return 0;
665 };
666
Pause()667 int Pause() override
668 {
669 return 0;
670 };
Stop()671 int Stop() override
672 {
673 return 0;
674 };
Next()675 int Next() override
676 {
677 return 0;
678 };
679
Previous()680 int Previous() override
681 {
682 return 0;
683 };
684
GetPlayerStatus(OHOS::CastEngine::PlayerStates & status)685 int GetPlayerStatus(OHOS::CastEngine::PlayerStates &status) override
686 {
687 return 0;
688 };
689
GetDuration(int & duration)690 int GetDuration(int &duration) override
691 {
692 return 0;
693 };
694
GetVolume(int32_t & volume)695 int GetVolume(int32_t &volume) override
696 {
697 return 0;
698 };
699
GetLoopMode(OHOS::CastEngine::LoopMode & loopMode)700 int GetLoopMode(OHOS::CastEngine::LoopMode &loopMode) override
701 {
702 return 0;
703 };
704
GetPlaySpeed(OHOS::CastEngine::PlaybackSpeed & speed)705 int GetPlaySpeed(OHOS::CastEngine::PlaybackSpeed &speed) override
706 {
707 return 0;
708 };
709
GetMediaInfoHolder(OHOS::CastEngine::MediaInfoHolder & hold)710 int GetMediaInfoHolder(OHOS::CastEngine::MediaInfoHolder &hold) override
711 {
712 return 0;
713 };
714
Release()715 int Release() override
716 {
717 return 0;
718 };
719 };
720
721 /**
722 * @tc.name: HwCastStreamPlayerSendControlCommandWithParams001
723 * @tc.desc: cmd : CAST_CONTROL_CMD_FAST_FORWARD
724 * @tc.type: FUNC
725 * @tc.require:
726 */
727 static HWTEST(HwCastTest, HwCastStreamPlayerSendControlCommandWithParams001, TestSize.Level1)
728 {
729 SLOGI("HwCastStreamPlayerSendControlCommandWithParams001 begin!");
730 std::shared_ptr<StreamPlayerImpl> player = std::make_shared<StreamPlayerImpl>();
731 std::shared_ptr<HwCastStreamPlayer> streamplayer = std::make_shared<HwCastStreamPlayer>(player);
732 EXPECT_EQ(streamplayer != nullptr, true);
733 streamplayer->Init();
734 AVCastControlCommand cmd;
735 cmd.SetCommand(OHOS::AVSession::AVCastControlCommand::CAST_CONTROL_CMD_FAST_FORWARD);
736 streamplayer->SendControlCommandWithParams(cmd);
737 SLOGI("HwCastStreamPlayerSendControlCommandWithParams001 end!");
738 }
739
740 /**
741 * @tc.name: HwCastStreamPlayerSendControlCommandWithParams002
742 * @tc.desc: cmd : CAST_CONTROL_CMD_REWIND
743 * @tc.type: FUNC
744 * @tc.require:
745 */
746 static HWTEST(HwCastTest, HwCastStreamPlayerSendControlCommandWithParams002, TestSize.Level1)
747 {
748 SLOGI("HwCastStreamPlayerSendControlCommandWithParams002 begin!");
749 std::shared_ptr<StreamPlayerImpl> player = std::make_shared<StreamPlayerImpl>();
750 std::shared_ptr<HwCastStreamPlayer> streamplayer = std::make_shared<HwCastStreamPlayer>(player);
751 EXPECT_EQ(streamplayer != nullptr, true);
752 streamplayer->Init();
753 AVCastControlCommand cmd;
754 cmd.SetCommand(OHOS::AVSession::AVCastControlCommand::CAST_CONTROL_CMD_REWIND);
755 streamplayer->SendControlCommandWithParams(cmd);
756 SLOGI("HwCastStreamPlayerSendControlCommandWithParams002 end!");
757 }
758
759 /**
760 * @tc.name: HwCastStreamPlayerSendControlCommandWithParams003
761 * @tc.desc: cmd : CAST_CONTROL_CMD_SEEK
762 * @tc.type: FUNC
763 * @tc.require:
764 */
765 static HWTEST(HwCastTest, HwCastStreamPlayerSendControlCommandWithParams003, TestSize.Level1)
766 {
767 SLOGI("HwCastStreamPlayerSendControlCommandWithParams003 begin!");
768 std::shared_ptr<StreamPlayerImpl> player = std::make_shared<StreamPlayerImpl>();
769 std::shared_ptr<HwCastStreamPlayer> streamplayer = std::make_shared<HwCastStreamPlayer>(player);
770 EXPECT_EQ(streamplayer != nullptr, true);
771 streamplayer->Init();
772 AVCastControlCommand cmd;
773 cmd.SetCommand(OHOS::AVSession::AVCastControlCommand::CAST_CONTROL_CMD_SEEK);
774 streamplayer->SendControlCommandWithParams(cmd);
775 SLOGI("HwCastStreamPlayerSendControlCommandWithParams003 end!");
776 }
777
778 /**
779 * @tc.name: HwCastStreamPlayerSendControlCommandWithParams004
780 * @tc.desc: cmd : CAST_CONTROL_CMD_SET_VOLUME
781 * @tc.type: FUNC
782 * @tc.require:
783 */
784 static HWTEST(HwCastTest, HwCastStreamPlayerSendControlCommandWithParams004, TestSize.Level1)
785 {
786 SLOGI("HwCastStreamPlayerSendControlCommandWithParams004 begin!");
787 std::shared_ptr<StreamPlayerImpl> player = std::make_shared<StreamPlayerImpl>();
788 std::shared_ptr<HwCastStreamPlayer> streamplayer = std::make_shared<HwCastStreamPlayer>(player);
789 EXPECT_EQ(streamplayer != nullptr, true);
790 streamplayer->Init();
791 AVCastControlCommand cmd;
792 cmd.SetCommand(OHOS::AVSession::AVCastControlCommand::CAST_CONTROL_CMD_SET_VOLUME);
793 streamplayer->SendControlCommandWithParams(cmd);
794 SLOGI("HwCastStreamPlayerSendControlCommandWithParams004 end!");
795 }
796
797 /**
798 * @tc.name: HwCastStreamPlayerSendControlCommandWithParams005
799 * @tc.desc: cmd : CAST_CONTROL_CMD_SET_SPEED
800 * @tc.type: FUNC
801 * @tc.require:
802 */
803 static HWTEST(HwCastTest, HwCastStreamPlayerSendControlCommandWithParams005, TestSize.Level1)
804 {
805 SLOGI("HwCastStreamPlayerSendControlCommandWithParams005 begin!");
806 std::shared_ptr<StreamPlayerImpl> player = std::make_shared<StreamPlayerImpl>();
807 std::shared_ptr<HwCastStreamPlayer> streamplayer = std::make_shared<HwCastStreamPlayer>(player);
808 EXPECT_EQ(streamplayer != nullptr, true);
809 streamplayer->Init();
810 AVCastControlCommand cmd;
811 cmd.SetCommand(OHOS::AVSession::AVCastControlCommand::CAST_CONTROL_CMD_SET_SPEED);
812 streamplayer->SendControlCommandWithParams(cmd);
813 SLOGI("HwCastStreamPlayerSendControlCommandWithParams005 end!");
814 }
815
816 /**
817 * @tc.name: HwCastStreamPlayerSendControlCommandWithParams006
818 * @tc.desc: cmd : CAST_CONTROL_CMD_SET_LOOP_MODE
819 * @tc.type: FUNC
820 * @tc.require:
821 */
822 static HWTEST(HwCastTest, HwCastStreamPlayerSendControlCommandWithParams006, TestSize.Level1)
823 {
824 SLOGI("HwCastStreamPlayerSendControlCommandWithParams006 begin!");
825 std::shared_ptr<StreamPlayerImpl> player = std::make_shared<StreamPlayerImpl>();
826 std::shared_ptr<HwCastStreamPlayer> streamplayer = std::make_shared<HwCastStreamPlayer>(player);
827 EXPECT_EQ(streamplayer != nullptr, true);
828 streamplayer->Init();
829 AVCastControlCommand cmd;
830 cmd.SetCommand(OHOS::AVSession::AVCastControlCommand::CAST_CONTROL_CMD_SET_LOOP_MODE);
831 streamplayer->SendControlCommandWithParams(cmd);
832 SLOGI("HwCastStreamPlayerSendControlCommandWithParams006 end!");
833 }
834
835 /**
836 * @tc.name: HwCastStreamPlayerSendControlCommandWithParams007
837 * @tc.desc: cmd : CAST_CONTROL_CMD_TOGGLE_FAVORITE
838 * @tc.type: FUNC
839 * @tc.require:
840 */
841 static HWTEST(HwCastTest, HwCastStreamPlayerSendControlCommandWithParams007, TestSize.Level1)
842 {
843 SLOGI("HwCastStreamPlayerSendControlCommandWithParams007 begin!");
844 std::shared_ptr<StreamPlayerImpl> player = std::make_shared<StreamPlayerImpl>();
845 std::shared_ptr<HwCastStreamPlayer> streamplayer = std::make_shared<HwCastStreamPlayer>(player);
846 EXPECT_EQ(streamplayer != nullptr, true);
847 streamplayer->Init();
848 AVCastControlCommand cmd;
849 cmd.SetCommand(OHOS::AVSession::AVCastControlCommand::CAST_CONTROL_CMD_TOGGLE_FAVORITE);
850 streamplayer->SendControlCommandWithParams(cmd);
851 SLOGI("HwCastStreamPlayerSendControlCommandWithParams007 end!");
852 }
853
854 /**
855 * @tc.name: HwCastStreamPlayerSendControlCommandWithParams008
856 * @tc.desc: cmd : CAST_CONTROL_CMD_INVALID
857 * @tc.type: FUNC
858 * @tc.require:
859 */
860 static HWTEST(HwCastTest, HwCastStreamPlayerSendControlCommandWithParams008, TestSize.Level1)
861 {
862 SLOGI("HwCastStreamPlayerSendControlCommandWithParams008 begin!");
863 std::shared_ptr<StreamPlayerImpl> player = std::make_shared<StreamPlayerImpl>();
864 std::shared_ptr<HwCastStreamPlayer> streamplayer = std::make_shared<HwCastStreamPlayer>(player);
865 EXPECT_EQ(streamplayer != nullptr, true);
866 streamplayer->Init();
867 AVCastControlCommand cmd;
868 cmd.SetCommand(OHOS::AVSession::AVCastControlCommand::CAST_CONTROL_CMD_INVALID);
869 streamplayer->SendControlCommandWithParams(cmd);
870 SLOGI("HwCastStreamPlayerSendControlCommandWithParams008 end!");
871 }
872
873 /**
874 * @tc.name: HwCastProviderInit001
875 * @tc.desc:
876 * @tc.type: FUNC
877 * @tc.require:
878 */
879 static HWTEST(HwCastTest, HwCastProviderInit001, TestSize.Level1)
880 {
881 SLOGI("HwCastProviderInit001 begin!");
882 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
883 EXPECT_EQ(hwCastProvider != nullptr, true);
884 hwCastProvider->Init();
885 SLOGI("HwCastProviderInit001 end!");
886 }
887
888 /**
889 * @tc.name: HwCastProviderStartDiscovery001
890 * @tc.desc:
891 * @tc.type: FUNC
892 * @tc.require:
893 */
894 static HWTEST(HwCastTest, HwCastProviderStartDiscovery001, TestSize.Level1)
895 {
896 SLOGI("HwCastProviderStartDiscovery001 begin!");
897 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
898 EXPECT_EQ(hwCastProvider != nullptr, true);
899 hwCastProvider->Init();
900 int castCapability = 0;
901 EXPECT_EQ(hwCastProvider->StartDiscovery(castCapability), true);
902 SLOGI("HwCastProviderStartDiscovery001 end!");
903 }
904
905 /**
906 * @tc.name: HwCastProviderStopDiscovery001
907 * @tc.desc:
908 * @tc.type: FUNC
909 * @tc.require:
910 */
911 static HWTEST(HwCastTest, HwCastProviderStopDiscovery001, TestSize.Level1)
912 {
913 SLOGI("HwCastProviderStopDiscovery001 begin!");
914 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
915 EXPECT_EQ(hwCastProvider != nullptr, true);
916 hwCastProvider->Init();
917 hwCastProvider->StopDiscovery();
918 SLOGI("HwCastProviderStopDiscovery001 end!");
919 }
920
921 /**
922 * @tc.name: HwCastProviderSetDiscoverable001
923 * @tc.desc:
924 * @tc.type: FUNC
925 * @tc.require:
926 */
927 static HWTEST(HwCastTest, HwCastProviderSetDiscoverable001, TestSize.Level1)
928 {
929 SLOGI("HwCastProviderSetDiscoverable001 begin!");
930 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
931 EXPECT_EQ(hwCastProvider != nullptr, true);
932 hwCastProvider->Init();
933 bool enable = true;
934 EXPECT_EQ(hwCastProvider->SetDiscoverable(enable), -1003);
935 SLOGI("HwCastProviderSetDiscoverable001 end!");
936 }
937
938 /**
939 * @tc.name: HwCastProviderRelease001
940 * @tc.desc:
941 * @tc.type: FUNC
942 * @tc.require:
943 */
944 static HWTEST(HwCastTest, HwCastProviderRelease001, TestSize.Level1)
945 {
946 SLOGI("HwCastProviderRelease001 begin!");
947 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
948 EXPECT_EQ(hwCastProvider != nullptr, true);
949 hwCastProvider->Init();
950 hwCastProvider->Release();
951 SLOGI("HwCastProviderRelease001 end!");
952 }
953
954 /**
955 * @tc.name: HwCastProviderStartCastSession001
956 * @tc.desc:
957 * @tc.type: FUNC
958 * @tc.require:
959 */
960 static HWTEST(HwCastTest, HwCastProviderStartCastSession001, TestSize.Level1)
961 {
962 SLOGI("HwCastProviderStartCastSession001 begin!");
963 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
964 EXPECT_EQ(hwCastProvider != nullptr, true);
965 hwCastProvider->Init();
966 EXPECT_EQ(hwCastProvider->StartCastSession(), AVSESSION_SUCCESS);
967 SLOGI("HwCastProviderStartCastSession001 end!");
968 }
969
970 /**
971 * @tc.name: HwCastProviderStopCastSession001
972 * @tc.desc:
973 * @tc.type: FUNC
974 * @tc.require:
975 */
976 static HWTEST(HwCastTest, HwCastProviderStopCastSession001, TestSize.Level1)
977 {
978 SLOGI("HwCastProviderStopCastSession001 begin!");
979 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
980 EXPECT_EQ(hwCastProvider != nullptr, true);
981 hwCastProvider->Init();
982 int castId = 0;
983 hwCastProvider->StopCastSession(castId);
984 SLOGI("HwCastProviderStopCastSession001 end!");
985 }
986
987 /**
988 * @tc.name: HwCastProviderAddCastDevice001
989 * @tc.desc:
990 * @tc.type: FUNC
991 * @tc.require:
992 */
993 static HWTEST(HwCastTest, HwCastProviderAddCastDevice001, TestSize.Level1)
994 {
995 SLOGI("HwCastProviderAddCastDevice001 begin!");
996 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
997 EXPECT_EQ(hwCastProvider != nullptr, true);
998 hwCastProvider->Init();
999 int castId = 0;
1000 DeviceInfo deviceInfo;
1001 EXPECT_EQ(hwCastProvider->AddCastDevice(castId, deviceInfo), false);
1002 SLOGI("HwCastProviderAddCastDevice001 end!");
1003 }
1004
1005 /**
1006 * @tc.name: HwCastProviderRemoveCastDevice001
1007 * @tc.desc:
1008 * @tc.type: FUNC
1009 * @tc.require:
1010 */
1011 static HWTEST(HwCastTest, HwCastProviderRemoveCastDevice001, TestSize.Level1)
1012 {
1013 SLOGI("HwCastProviderRemoveCastDevice001 begin!");
1014 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
1015 EXPECT_EQ(hwCastProvider != nullptr, true);
1016 hwCastProvider->Init();
1017 int castId = 0;
1018 DeviceInfo deviceInfo;
1019 EXPECT_EQ(hwCastProvider->RemoveCastDevice(castId, deviceInfo), false);
1020 SLOGI("HwCastProviderRemoveCastDevice001 end!");
1021 }
1022
1023 /**
1024 * @tc.name: HwCastProviderGetRemoteController001
1025 * @tc.desc:
1026 * @tc.type: FUNC
1027 * @tc.require:
1028 */
1029 static HWTEST(HwCastTest, HwCastProviderGetRemoteController001, TestSize.Level1)
1030 {
1031 SLOGI("HwCastProviderGetRemoteController001 begin!");
1032 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
1033 EXPECT_EQ(hwCastProvider != nullptr, true);
1034 hwCastProvider->Init();
1035 int castId = 0;
1036 EXPECT_EQ(hwCastProvider->GetRemoteController(castId), nullptr);
1037 SLOGI("HwCastProviderGetRemoteController001 end!");
1038 }
1039
1040 /**
1041 * @tc.name: HwCastProviderRegisterCastStateListener001
1042 * @tc.desc:
1043 * @tc.type: FUNC
1044 * @tc.require:
1045 */
1046 static HWTEST(HwCastTest, HwCastProviderRegisterCastStateListener001, TestSize.Level1)
1047 {
1048 SLOGI("HwCastProviderRegisterCastStateListener001 begin!");
1049 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
1050 EXPECT_EQ(hwCastProvider != nullptr, true);
1051 hwCastProvider->Init();
1052 EXPECT_EQ(hwCastProvider->RegisterCastStateListener(nullptr), false);
1053 SLOGI("HwCastProviderRegisterCastStateListener001 end!");
1054 }
1055
1056 /**
1057 * @tc.name: HwCastProviderUnregisterCastStateListener001
1058 * @tc.desc:
1059 * @tc.type: FUNC
1060 * @tc.require:
1061 */
1062 static HWTEST(HwCastTest, HwCastProviderUnregisterCastStateListener001, TestSize.Level1)
1063 {
1064 SLOGI("HwCastProviderUnregisterCastStateListener001 begin!");
1065 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
1066 EXPECT_EQ(hwCastProvider != nullptr, true);
1067 hwCastProvider->Init();
1068 EXPECT_EQ(hwCastProvider->UnRegisterCastStateListener(nullptr), false);
1069 SLOGI("HwCastProviderUnregisterCastStateListener001 end!");
1070 }
1071
1072 /**
1073 * @tc.name: HwCastProviderRegisterCastSessionStateListener001
1074 * @tc.desc:
1075 * @tc.type: FUNC
1076 * @tc.require:
1077 */
1078 static HWTEST(HwCastTest, HwCastProviderRegisterCastSessionStateListener001, TestSize.Level1)
1079 {
1080 SLOGI("HwCastProviderRegisterCastSessionStateListener001 begin!");
1081 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
1082 EXPECT_EQ(hwCastProvider != nullptr, true);
1083 hwCastProvider->Init();
1084 int castId = 0;
1085 EXPECT_EQ(hwCastProvider->RegisterCastSessionStateListener(castId, nullptr), false);
1086 SLOGI("HwCastProviderRegisterCastSessionStateListener001 end!");
1087 }
1088
1089 /**
1090 * @tc.name: HwCastProviderUnregisterCastSessionStateListener001
1091 * @tc.desc:
1092 * @tc.type: FUNC
1093 * @tc.require:
1094 */
1095 static HWTEST(HwCastTest, HwCastProviderUnregisterCastSessionStateListener001, TestSize.Level1)
1096 {
1097 SLOGI("HwCastProviderUnregisterCastSessionStateListener001 begin!");
1098 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
1099 EXPECT_EQ(hwCastProvider != nullptr, true);
1100 hwCastProvider->Init();
1101 int castId = 0;
1102 EXPECT_EQ(hwCastProvider->RegisterCastSessionStateListener(castId, nullptr), false);
1103 SLOGI("HwCastProviderUnregisterCastSessionStateListener001 end!");
1104 }
1105
1106 /**
1107 * @tc.name: HwCastProviderOnDeviceFound001
1108 * @tc.desc:
1109 * @tc.type: FUNC
1110 * @tc.require:
1111 */
1112 static HWTEST(HwCastTest, HwCastProviderOnDeviceFound001, TestSize.Level1)
1113 {
1114 SLOGI("HwCastProviderOnDeviceFound001 begin!");
1115 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
1116 EXPECT_EQ(hwCastProvider != nullptr, true);
1117 hwCastProvider->Init();
1118 std::vector<OHOS::CastEngine::CastRemoteDevice> device;
1119 hwCastProvider->OnDeviceFound(device);
1120 SLOGI("HwCastProviderOnDeviceFound001 end!");
1121 }
1122
1123 /**
1124 * @tc.name: HwCastProviderOnSessionCreated001
1125 * @tc.desc:
1126 * @tc.type: FUNC
1127 * @tc.require:
1128 */
1129 static HWTEST(HwCastTest, HwCastProviderOnSessionCreated001, TestSize.Level1)
1130 {
1131 SLOGI("HwCastProviderOnSessionCreated001 begin!");
1132 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
1133 EXPECT_EQ(hwCastProvider != nullptr, true);
1134 hwCastProvider->Init();
1135 hwCastProvider->OnSessionCreated(nullptr);
1136 SLOGI("HwCastProviderOnSessionCreated001 end!");
1137 }
1138
1139 /**
1140 * @tc.name: HwCastProviderOnServiceDied001
1141 * @tc.desc:
1142 * @tc.type: FUNC
1143 * @tc.require:
1144 */
1145 static HWTEST(HwCastTest, HwCastProviderOnServiceDied001, TestSize.Level1)
1146 {
1147 SLOGI("HwCastProviderOnServiceDied001 begin!");
1148 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
1149 EXPECT_EQ(hwCastProvider != nullptr, true);
1150 hwCastProvider->Init();
1151 hwCastProvider->OnServiceDied();
1152 SLOGI("HwCastProviderOnServiceDied001 end!");
1153 }
1154
1155 /**
1156 * @tc.name: HwCastProviderSessionInit001
1157 * @tc.desc:
1158 * @tc.type: FUNC
1159 * @tc.require:
1160 */
1161 static HWTEST(HwCastTest, HwCastProviderSessionInit001, TestSize.Level1)
1162 {
1163 SLOGI("HwCastProviderSessionInit001 begin!");
1164 std::shared_ptr<HwCastProviderSession> provideSession = std::make_shared<HwCastProviderSession>(nullptr);
1165 EXPECT_EQ(provideSession != nullptr, true);
1166 provideSession->Init();
1167 SLOGI("HwCastProviderSessionInit001 end!");
1168 }
1169
1170 /**
1171 * @tc.name: HwCastProviderSessionRelease001
1172 * @tc.desc:
1173 * @tc.type: FUNC
1174 * @tc.require:
1175 */
1176 static HWTEST(HwCastTest, HwCastProviderSessionRelease001, TestSize.Level1)
1177 {
1178 SLOGI("HwCastProviderSessionRelease001 begin!");
1179 std::shared_ptr<HwCastProviderSession> provideSession = std::make_shared<HwCastProviderSession>(nullptr);
1180 EXPECT_EQ(provideSession != nullptr, true);
1181 provideSession->Init();
1182 provideSession->Release();
1183 SLOGI("HwCastProviderSessionRelease001 end!");
1184 }
1185
1186 /**
1187 * @tc.name: HwCastProviderSessionOnDeviceState001
1188 * @tc.desc:
1189 * @tc.type: FUNC
1190 * @tc.require:
1191 */
1192 static HWTEST(HwCastTest, HwCastProviderSessionOnDeviceState001, TestSize.Level1)
1193 {
1194 SLOGI("HwCastProviderSessionOnDeviceState001 begin!");
1195 std::shared_ptr<HwCastProviderSession> provideSession = std::make_shared<HwCastProviderSession>(nullptr);
1196 EXPECT_EQ(provideSession != nullptr, true);
1197 provideSession->Init();
1198 OHOS::CastEngine::DeviceStateInfo stateInfo;
1199 stateInfo.deviceId = "testDeviceId";
1200 provideSession->OnDeviceState(stateInfo);
1201 SLOGI("HwCastProviderSessionOnDeviceState001 end!");
1202 }
1203
1204 /**
1205 * @tc.name: HwCastProviderSessionAddDevice001
1206 * @tc.desc:
1207 * @tc.type: FUNC
1208 * @tc.require:
1209 */
1210 static HWTEST(HwCastTest, HwCastProviderSessionAddDevice001, TestSize.Level1)
1211 {
1212 SLOGI("HwCastProviderSessionAddDevice001 begin!");
1213 std::shared_ptr<HwCastProviderSession> provideSession = std::make_shared<HwCastProviderSession>(nullptr);
1214 EXPECT_EQ(provideSession != nullptr, true);
1215 provideSession->Init();
1216 std::string deviceId = "deviceId";
1217 EXPECT_EQ(provideSession->AddDevice(deviceId), false);
1218 SLOGI("HwCastProviderSessionAddDevice001 end!");
1219 }
1220
1221 /**
1222 * @tc.name: HwCastProviderSessionRemoveDevice001
1223 * @tc.desc:
1224 * @tc.type: FUNC
1225 * @tc.require:
1226 */
1227 static HWTEST(HwCastTest, HwCastProviderSessionRemoveDevice001, TestSize.Level1)
1228 {
1229 SLOGI("HwCastProviderSessionRemoveDevice001 begin!");
1230 std::shared_ptr<HwCastProviderSession> provideSession = std::make_shared<HwCastProviderSession>(nullptr);
1231 EXPECT_EQ(provideSession != nullptr, true);
1232 provideSession->Init();
1233 std::string deviceId = "deviceId";
1234 EXPECT_EQ(provideSession->RemoveDevice(deviceId), false);
1235 SLOGI("HwCastProviderSessionRemoveDevice001 end!");
1236 }
1237
1238 /**
1239 * @tc.name: HwCastProviderSessionCreateStreamPlayer001
1240 * @tc.desc:
1241 * @tc.type: FUNC
1242 * @tc.require:
1243 */
1244 static HWTEST(HwCastTest, HwCastProviderSessionCreateStreamPlayer001, TestSize.Level1)
1245 {
1246 SLOGI("HwCastProviderSessionCreateStreamPlayer001 begin!");
1247 std::shared_ptr<HwCastProviderSession> provideSession = std::make_shared<HwCastProviderSession>(nullptr);
1248 EXPECT_EQ(provideSession != nullptr, true);
1249 provideSession->Init();
1250 EXPECT_EQ(provideSession->CreateStreamPlayer(), nullptr);
1251 SLOGI("HwCastProviderSessionCreateStreamPlayer001 end!");
1252 }
1253
1254 /**
1255 * @tc.name: HwCastProviderSessionRegisterCastSessionStateListener001
1256 * @tc.desc:
1257 * @tc.type: FUNC
1258 * @tc.require:
1259 */
1260 static HWTEST(HwCastTest, HwCastProviderSessionRegisterCastSessionStateListener001, TestSize.Level1)
1261 {
1262 SLOGI("HwCastProviderSessionRegisterCastSessionStateListener001 begin!");
1263 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
1264 EXPECT_EQ(hwCastProvider != nullptr, true);
1265 hwCastProvider->Init();
1266 EXPECT_EQ(hwCastProvider->RegisterCastSessionStateListener(0, nullptr), false);
1267 SLOGI("HwCastProviderSessionRegisterCastSessionStateListener001 end!");
1268 }
1269
1270 /**
1271 * @tc.name: HwCastProviderSessionUnregisterCastSessionStateListener001
1272 * @tc.desc:
1273 * @tc.type: FUNC
1274 * @tc.require:
1275 */
1276 static HWTEST(HwCastTest, HwCastProviderSessionUnregisterCastSessionStateListener001, TestSize.Level1)
1277 {
1278 SLOGI("HwCastProviderSessionUnregisterCastSessionStateListener001 begin!");
1279 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
1280 EXPECT_EQ(hwCastProvider != nullptr, true);
1281 EXPECT_EQ(hwCastProvider->UnRegisterCastSessionStateListener(0, nullptr), false);
1282 SLOGI("HwCastProviderSessionUnregisterCastSessionStateListener001 end!");
1283 }
1284