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 /**
607 * @tc.name: HwCastStreamPlayerOnPlayRequest001
608 * @tc.desc:
609 * @tc.type: FUNC
610 * @tc.require:
611 */
612 static HWTEST(HwCastTest, HwCastStreamPlayerOnPlayRequest001, TestSize.Level1)
613 {
614 SLOGI("HwCastStreamPlayerOnPlayRequest001 begin!");
615 std::shared_ptr<HwCastStreamPlayer> streamplayer = std::make_shared<HwCastStreamPlayer>(nullptr);
616 EXPECT_EQ(streamplayer != nullptr, true);
617 streamplayer->Init();
618 OHOS::CastEngine::MediaInfo mediaInfo;
619 streamplayer->OnPlayRequest(mediaInfo);
620 SLOGI("HwCastStreamPlayerOnPlayRequest001 end!");
621 }
622
623 class StreamPlayerImpl : public OHOS::CastEngine::IStreamPlayer {
624 public:
GetPosition(int32_t & currentPosition)625 int GetPosition(int32_t& currentPosition) override
626 {
627 return 0;
628 };
629
Seek(int32_t position)630 int Seek(int32_t position) override
631 {
632 return 0;
633 };
634
SetSpeed(const OHOS::CastEngine::PlaybackSpeed speed)635 int SetSpeed(const OHOS::CastEngine::PlaybackSpeed speed) override
636 {
637 return 0;
638 };
639
FastForward(const int32_t delta)640 int FastForward(const int32_t delta) override
641 {
642 return 0;
643 };
644
FastRewind(const int32_t delta)645 int FastRewind(const int32_t delta) override
646 {
647 return 0;
648 };
649
SetVolume(const int32_t volume)650 int SetVolume(const int32_t volume) override
651 {
652 return 0;
653 };
654
SetMute(bool mute)655 int SetMute(bool mute) override
656 {
657 return 0;
658 };
659
SetLoopMode(const OHOS::CastEngine::LoopMode loopMode)660 int SetLoopMode(const OHOS::CastEngine::LoopMode loopMode) override
661 {
662 return 0;
663 };
664
RegisterListener(std::shared_ptr<OHOS::CastEngine::IStreamPlayerListener> listener)665 int RegisterListener(std::shared_ptr<OHOS::CastEngine::IStreamPlayerListener> listener) override
666 {
667 return 0;
668 };
669
UnregisterListener()670 int UnregisterListener() override
671 {
672 return 0;
673 };
674
SetSurface(const std::string & surfaceInfo)675 int SetSurface(const std::string &surfaceInfo) override
676 {
677 return 0;
678 };
679
Load(const OHOS::CastEngine::MediaInfo & media)680 int Load(const OHOS::CastEngine::MediaInfo &media) override
681 {
682 return 0;
683 };
684
Play()685 int Play() override
686 {
687 return 0;
688 };
689
Play(const OHOS::CastEngine::MediaInfo & media)690 int Play(const OHOS::CastEngine::MediaInfo &media) override
691 {
692 return 0;
693 };
694
Play(int index)695 int Play(int index) override
696 {
697 return 0;
698 };
699
Pause()700 int Pause() override
701 {
702 return 0;
703 };
Stop()704 int Stop() override
705 {
706 return 0;
707 };
Next()708 int Next() override
709 {
710 return 0;
711 };
712
Previous()713 int Previous() override
714 {
715 return 0;
716 };
717
GetPlayerStatus(OHOS::CastEngine::PlayerStates & status)718 int GetPlayerStatus(OHOS::CastEngine::PlayerStates &status) override
719 {
720 return 0;
721 };
722
GetDuration(int & duration)723 int GetDuration(int &duration) override
724 {
725 return 0;
726 };
727
GetVolume(int32_t & volume)728 int GetVolume(int32_t &volume) override
729 {
730 return 0;
731 };
732
GetMute(bool & mute)733 int GetMute(bool &mute) override
734 {
735 return 0;
736 };
737
GetLoopMode(OHOS::CastEngine::LoopMode & loopMode)738 int GetLoopMode(OHOS::CastEngine::LoopMode &loopMode) override
739 {
740 return 0;
741 };
742
GetPlaySpeed(OHOS::CastEngine::PlaybackSpeed & speed)743 int GetPlaySpeed(OHOS::CastEngine::PlaybackSpeed &speed) override
744 {
745 return 0;
746 };
747
GetMediaInfoHolder(OHOS::CastEngine::MediaInfoHolder & hold)748 int GetMediaInfoHolder(OHOS::CastEngine::MediaInfoHolder &hold) override
749 {
750 return 0;
751 };
752
Release()753 int Release() override
754 {
755 return 0;
756 };
757 };
758
759 /**
760 * @tc.name: HwCastStreamPlayerSendControlCommandWithParams001
761 * @tc.desc: cmd : CAST_CONTROL_CMD_FAST_FORWARD
762 * @tc.type: FUNC
763 * @tc.require:
764 */
765 static HWTEST(HwCastTest, HwCastStreamPlayerSendControlCommandWithParams001, TestSize.Level1)
766 {
767 SLOGI("HwCastStreamPlayerSendControlCommandWithParams001 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_FAST_FORWARD);
774 streamplayer->SendControlCommandWithParams(cmd);
775 SLOGI("HwCastStreamPlayerSendControlCommandWithParams001 end!");
776 }
777
778 /**
779 * @tc.name: HwCastStreamPlayerSendControlCommandWithParams002
780 * @tc.desc: cmd : CAST_CONTROL_CMD_REWIND
781 * @tc.type: FUNC
782 * @tc.require:
783 */
784 static HWTEST(HwCastTest, HwCastStreamPlayerSendControlCommandWithParams002, TestSize.Level1)
785 {
786 SLOGI("HwCastStreamPlayerSendControlCommandWithParams002 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_REWIND);
793 streamplayer->SendControlCommandWithParams(cmd);
794 SLOGI("HwCastStreamPlayerSendControlCommandWithParams002 end!");
795 }
796
797 /**
798 * @tc.name: HwCastStreamPlayerSendControlCommandWithParams003
799 * @tc.desc: cmd : CAST_CONTROL_CMD_SEEK
800 * @tc.type: FUNC
801 * @tc.require:
802 */
803 static HWTEST(HwCastTest, HwCastStreamPlayerSendControlCommandWithParams003, TestSize.Level1)
804 {
805 SLOGI("HwCastStreamPlayerSendControlCommandWithParams003 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_SEEK);
812 streamplayer->SendControlCommandWithParams(cmd);
813 SLOGI("HwCastStreamPlayerSendControlCommandWithParams003 end!");
814 }
815
816 /**
817 * @tc.name: HwCastStreamPlayerSendControlCommandWithParams004
818 * @tc.desc: cmd : CAST_CONTROL_CMD_SET_VOLUME
819 * @tc.type: FUNC
820 * @tc.require:
821 */
822 static HWTEST(HwCastTest, HwCastStreamPlayerSendControlCommandWithParams004, TestSize.Level1)
823 {
824 SLOGI("HwCastStreamPlayerSendControlCommandWithParams004 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_VOLUME);
831 streamplayer->SendControlCommandWithParams(cmd);
832 SLOGI("HwCastStreamPlayerSendControlCommandWithParams004 end!");
833 }
834
835 /**
836 * @tc.name: HwCastStreamPlayerSendControlCommandWithParams005
837 * @tc.desc: cmd : CAST_CONTROL_CMD_SET_SPEED
838 * @tc.type: FUNC
839 * @tc.require:
840 */
841 static HWTEST(HwCastTest, HwCastStreamPlayerSendControlCommandWithParams005, TestSize.Level1)
842 {
843 SLOGI("HwCastStreamPlayerSendControlCommandWithParams005 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_SET_SPEED);
850 streamplayer->SendControlCommandWithParams(cmd);
851 SLOGI("HwCastStreamPlayerSendControlCommandWithParams005 end!");
852 }
853
854 /**
855 * @tc.name: HwCastStreamPlayerSendControlCommandWithParams006
856 * @tc.desc: cmd : CAST_CONTROL_CMD_SET_LOOP_MODE
857 * @tc.type: FUNC
858 * @tc.require:
859 */
860 static HWTEST(HwCastTest, HwCastStreamPlayerSendControlCommandWithParams006, TestSize.Level1)
861 {
862 SLOGI("HwCastStreamPlayerSendControlCommandWithParams006 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_SET_LOOP_MODE);
869 streamplayer->SendControlCommandWithParams(cmd);
870 SLOGI("HwCastStreamPlayerSendControlCommandWithParams006 end!");
871 }
872
873 /**
874 * @tc.name: HwCastStreamPlayerSendControlCommandWithParams007
875 * @tc.desc: cmd : CAST_CONTROL_CMD_TOGGLE_FAVORITE
876 * @tc.type: FUNC
877 * @tc.require:
878 */
879 static HWTEST(HwCastTest, HwCastStreamPlayerSendControlCommandWithParams007, TestSize.Level1)
880 {
881 SLOGI("HwCastStreamPlayerSendControlCommandWithParams007 begin!");
882 std::shared_ptr<StreamPlayerImpl> player = std::make_shared<StreamPlayerImpl>();
883 std::shared_ptr<HwCastStreamPlayer> streamplayer = std::make_shared<HwCastStreamPlayer>(player);
884 EXPECT_EQ(streamplayer != nullptr, true);
885 streamplayer->Init();
886 AVCastControlCommand cmd;
887 cmd.SetCommand(OHOS::AVSession::AVCastControlCommand::CAST_CONTROL_CMD_TOGGLE_FAVORITE);
888 streamplayer->SendControlCommandWithParams(cmd);
889 SLOGI("HwCastStreamPlayerSendControlCommandWithParams007 end!");
890 }
891
892 /**
893 * @tc.name: HwCastStreamPlayerSendControlCommandWithParams008
894 * @tc.desc: cmd : CAST_CONTROL_CMD_TOGGLE_MUTE
895 * @tc.type: FUNC
896 * @tc.require:
897 */
898 static HWTEST(HwCastTest, HwCastStreamPlayerSendControlCommandWithParams008, TestSize.Level1)
899 {
900 SLOGI("HwCastStreamPlayerSendControlCommandWithParams008 begin!");
901 std::shared_ptr<StreamPlayerImpl> player = std::make_shared<StreamPlayerImpl>();
902 std::shared_ptr<HwCastStreamPlayer> streamplayer = std::make_shared<HwCastStreamPlayer>(player);
903 EXPECT_EQ(streamplayer != nullptr, true);
904 streamplayer->Init();
905 AVCastControlCommand cmd;
906 cmd.SetCommand(OHOS::AVSession::AVCastControlCommand::CAST_CONTROL_CMD_TOGGLE_MUTE);
907 streamplayer->SendControlCommandWithParams(cmd);
908 SLOGI("HwCastStreamPlayerSendControlCommandWithParams008 end!");
909 }
910
911 /**
912 * @tc.name: HwCastStreamPlayerSendControlCommandWithParams009
913 * @tc.desc: cmd : CAST_CONTROL_CMD_INVALID
914 * @tc.type: FUNC
915 * @tc.require:
916 */
917 static HWTEST(HwCastTest, HwCastStreamPlayerSendControlCommandWithParams009, TestSize.Level1)
918 {
919 SLOGI("HwCastStreamPlayerSendControlCommandWithParams009 begin!");
920 std::shared_ptr<StreamPlayerImpl> player = std::make_shared<StreamPlayerImpl>();
921 std::shared_ptr<HwCastStreamPlayer> streamplayer = std::make_shared<HwCastStreamPlayer>(player);
922 EXPECT_EQ(streamplayer != nullptr, true);
923 streamplayer->Init();
924 AVCastControlCommand cmd;
925 cmd.SetCommand(OHOS::AVSession::AVCastControlCommand::CAST_CONTROL_CMD_INVALID);
926 streamplayer->SendControlCommandWithParams(cmd);
927 SLOGI("HwCastStreamPlayerSendControlCommandWithParams009 end!");
928 }
929
930 /**
931 * @tc.name: HwCastProviderInit001
932 * @tc.desc:
933 * @tc.type: FUNC
934 * @tc.require:
935 */
936 static HWTEST(HwCastTest, HwCastProviderInit001, TestSize.Level1)
937 {
938 SLOGI("HwCastProviderInit001 begin!");
939 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
940 EXPECT_EQ(hwCastProvider != nullptr, true);
941 hwCastProvider->Init();
942 SLOGI("HwCastProviderInit001 end!");
943 }
944
945 /**
946 * @tc.name: HwCastProviderStartDiscovery001
947 * @tc.desc:
948 * @tc.type: FUNC
949 * @tc.require:
950 */
951 static HWTEST(HwCastTest, HwCastProviderStartDiscovery001, TestSize.Level1)
952 {
953 SLOGI("HwCastProviderStartDiscovery001 begin!");
954 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
955 EXPECT_EQ(hwCastProvider != nullptr, true);
956 hwCastProvider->Init();
957 int castCapability = 0;
958 EXPECT_EQ(hwCastProvider->StartDiscovery(castCapability), true);
959 SLOGI("HwCastProviderStartDiscovery001 end!");
960 }
961
962 /**
963 * @tc.name: HwCastProviderStopDiscovery001
964 * @tc.desc:
965 * @tc.type: FUNC
966 * @tc.require:
967 */
968 static HWTEST(HwCastTest, HwCastProviderStopDiscovery001, TestSize.Level1)
969 {
970 SLOGI("HwCastProviderStopDiscovery001 begin!");
971 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
972 EXPECT_EQ(hwCastProvider != nullptr, true);
973 hwCastProvider->Init();
974 hwCastProvider->StopDiscovery();
975 SLOGI("HwCastProviderStopDiscovery001 end!");
976 }
977
978 /**
979 * @tc.name: HwCastProviderSetDiscoverable001
980 * @tc.desc:
981 * @tc.type: FUNC
982 * @tc.require:
983 */
984 static HWTEST(HwCastTest, HwCastProviderSetDiscoverable001, TestSize.Level1)
985 {
986 SLOGI("HwCastProviderSetDiscoverable001 begin!");
987 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
988 EXPECT_EQ(hwCastProvider != nullptr, true);
989 hwCastProvider->Init();
990 bool enable = true;
991 EXPECT_EQ(hwCastProvider->SetDiscoverable(enable), -1003);
992 SLOGI("HwCastProviderSetDiscoverable001 end!");
993 }
994
995 /**
996 * @tc.name: HwCastProviderRelease001
997 * @tc.desc:
998 * @tc.type: FUNC
999 * @tc.require:
1000 */
1001 static HWTEST(HwCastTest, HwCastProviderRelease001, TestSize.Level1)
1002 {
1003 SLOGI("HwCastProviderRelease001 begin!");
1004 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
1005 EXPECT_EQ(hwCastProvider != nullptr, true);
1006 hwCastProvider->Init();
1007 hwCastProvider->Release();
1008 SLOGI("HwCastProviderRelease001 end!");
1009 }
1010
1011 /**
1012 * @tc.name: HwCastProviderStartCastSession001
1013 * @tc.desc:
1014 * @tc.type: FUNC
1015 * @tc.require:
1016 */
1017 static HWTEST(HwCastTest, HwCastProviderStartCastSession001, TestSize.Level1)
1018 {
1019 SLOGI("HwCastProviderStartCastSession001 begin!");
1020 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
1021 EXPECT_EQ(hwCastProvider != nullptr, true);
1022 hwCastProvider->Init();
1023 EXPECT_EQ(hwCastProvider->StartCastSession(), AVSESSION_SUCCESS);
1024 SLOGI("HwCastProviderStartCastSession001 end!");
1025 }
1026
1027 /**
1028 * @tc.name: HwCastProviderStopCastSession001
1029 * @tc.desc:
1030 * @tc.type: FUNC
1031 * @tc.require:
1032 */
1033 static HWTEST(HwCastTest, HwCastProviderStopCastSession001, TestSize.Level1)
1034 {
1035 SLOGI("HwCastProviderStopCastSession001 begin!");
1036 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
1037 EXPECT_EQ(hwCastProvider != nullptr, true);
1038 hwCastProvider->Init();
1039 int castId = 0;
1040 hwCastProvider->StopCastSession(castId);
1041 SLOGI("HwCastProviderStopCastSession001 end!");
1042 }
1043
1044 /**
1045 * @tc.name: HwCastProviderAddCastDevice001
1046 * @tc.desc:
1047 * @tc.type: FUNC
1048 * @tc.require:
1049 */
1050 static HWTEST(HwCastTest, HwCastProviderAddCastDevice001, TestSize.Level1)
1051 {
1052 SLOGI("HwCastProviderAddCastDevice001 begin!");
1053 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
1054 EXPECT_EQ(hwCastProvider != nullptr, true);
1055 hwCastProvider->Init();
1056 int castId = 0;
1057 DeviceInfo deviceInfo;
1058 EXPECT_EQ(hwCastProvider->AddCastDevice(castId, deviceInfo), false);
1059 SLOGI("HwCastProviderAddCastDevice001 end!");
1060 }
1061
1062 /**
1063 * @tc.name: HwCastProviderRemoveCastDevice001
1064 * @tc.desc:
1065 * @tc.type: FUNC
1066 * @tc.require:
1067 */
1068 static HWTEST(HwCastTest, HwCastProviderRemoveCastDevice001, TestSize.Level1)
1069 {
1070 SLOGI("HwCastProviderRemoveCastDevice001 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 DeviceInfo deviceInfo;
1076 EXPECT_EQ(hwCastProvider->RemoveCastDevice(castId, deviceInfo), false);
1077 SLOGI("HwCastProviderRemoveCastDevice001 end!");
1078 }
1079
1080 /**
1081 * @tc.name: HwCastProviderGetRemoteController001
1082 * @tc.desc:
1083 * @tc.type: FUNC
1084 * @tc.require:
1085 */
1086 static HWTEST(HwCastTest, HwCastProviderGetRemoteController001, TestSize.Level1)
1087 {
1088 SLOGI("HwCastProviderGetRemoteController001 begin!");
1089 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
1090 EXPECT_EQ(hwCastProvider != nullptr, true);
1091 hwCastProvider->Init();
1092 int castId = 0;
1093 EXPECT_EQ(hwCastProvider->GetRemoteController(castId), nullptr);
1094 SLOGI("HwCastProviderGetRemoteController001 end!");
1095 }
1096
1097 /**
1098 * @tc.name: HwCastProviderRegisterCastStateListener001
1099 * @tc.desc:
1100 * @tc.type: FUNC
1101 * @tc.require:
1102 */
1103 static HWTEST(HwCastTest, HwCastProviderRegisterCastStateListener001, TestSize.Level1)
1104 {
1105 SLOGI("HwCastProviderRegisterCastStateListener001 begin!");
1106 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
1107 EXPECT_EQ(hwCastProvider != nullptr, true);
1108 hwCastProvider->Init();
1109 EXPECT_EQ(hwCastProvider->RegisterCastStateListener(nullptr), false);
1110 SLOGI("HwCastProviderRegisterCastStateListener001 end!");
1111 }
1112
1113 /**
1114 * @tc.name: HwCastProviderUnregisterCastStateListener001
1115 * @tc.desc:
1116 * @tc.type: FUNC
1117 * @tc.require:
1118 */
1119 static HWTEST(HwCastTest, HwCastProviderUnregisterCastStateListener001, TestSize.Level1)
1120 {
1121 SLOGI("HwCastProviderUnregisterCastStateListener001 begin!");
1122 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
1123 EXPECT_EQ(hwCastProvider != nullptr, true);
1124 hwCastProvider->Init();
1125 EXPECT_EQ(hwCastProvider->UnRegisterCastStateListener(nullptr), false);
1126 SLOGI("HwCastProviderUnregisterCastStateListener001 end!");
1127 }
1128
1129 /**
1130 * @tc.name: HwCastProviderRegisterCastSessionStateListener001
1131 * @tc.desc:
1132 * @tc.type: FUNC
1133 * @tc.require:
1134 */
1135 static HWTEST(HwCastTest, HwCastProviderRegisterCastSessionStateListener001, TestSize.Level1)
1136 {
1137 SLOGI("HwCastProviderRegisterCastSessionStateListener001 begin!");
1138 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
1139 EXPECT_EQ(hwCastProvider != nullptr, true);
1140 hwCastProvider->Init();
1141 int castId = 0;
1142 EXPECT_EQ(hwCastProvider->RegisterCastSessionStateListener(castId, nullptr), false);
1143 SLOGI("HwCastProviderRegisterCastSessionStateListener001 end!");
1144 }
1145
1146 /**
1147 * @tc.name: HwCastProviderUnregisterCastSessionStateListener001
1148 * @tc.desc:
1149 * @tc.type: FUNC
1150 * @tc.require:
1151 */
1152 static HWTEST(HwCastTest, HwCastProviderUnregisterCastSessionStateListener001, TestSize.Level1)
1153 {
1154 SLOGI("HwCastProviderUnregisterCastSessionStateListener001 begin!");
1155 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
1156 EXPECT_EQ(hwCastProvider != nullptr, true);
1157 hwCastProvider->Init();
1158 int castId = 0;
1159 EXPECT_EQ(hwCastProvider->RegisterCastSessionStateListener(castId, nullptr), false);
1160 SLOGI("HwCastProviderUnregisterCastSessionStateListener001 end!");
1161 }
1162
1163 /**
1164 * @tc.name: HwCastProviderOnDeviceFound001
1165 * @tc.desc:
1166 * @tc.type: FUNC
1167 * @tc.require:
1168 */
1169 static HWTEST(HwCastTest, HwCastProviderOnDeviceFound001, TestSize.Level1)
1170 {
1171 SLOGI("HwCastProviderOnDeviceFound001 begin!");
1172 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
1173 EXPECT_EQ(hwCastProvider != nullptr, true);
1174 hwCastProvider->Init();
1175 std::vector<OHOS::CastEngine::CastRemoteDevice> device;
1176 hwCastProvider->OnDeviceFound(device);
1177 SLOGI("HwCastProviderOnDeviceFound001 end!");
1178 }
1179
1180 /**
1181 * @tc.name: HwCastProviderOnSessionCreated001
1182 * @tc.desc:
1183 * @tc.type: FUNC
1184 * @tc.require:
1185 */
1186 static HWTEST(HwCastTest, HwCastProviderOnSessionCreated001, TestSize.Level1)
1187 {
1188 SLOGI("HwCastProviderOnSessionCreated001 begin!");
1189 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
1190 EXPECT_EQ(hwCastProvider != nullptr, true);
1191 hwCastProvider->Init();
1192 hwCastProvider->OnSessionCreated(nullptr);
1193 SLOGI("HwCastProviderOnSessionCreated001 end!");
1194 }
1195
1196 /**
1197 * @tc.name: HwCastProviderOnServiceDied001
1198 * @tc.desc:
1199 * @tc.type: FUNC
1200 * @tc.require:
1201 */
1202 static HWTEST(HwCastTest, HwCastProviderOnServiceDied001, TestSize.Level1)
1203 {
1204 SLOGI("HwCastProviderOnServiceDied001 begin!");
1205 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
1206 EXPECT_EQ(hwCastProvider != nullptr, true);
1207 hwCastProvider->Init();
1208 hwCastProvider->OnServiceDied();
1209 SLOGI("HwCastProviderOnServiceDied001 end!");
1210 }
1211
1212 /**
1213 * @tc.name: HwCastProviderSessionInit001
1214 * @tc.desc:
1215 * @tc.type: FUNC
1216 * @tc.require:
1217 */
1218 static HWTEST(HwCastTest, HwCastProviderSessionInit001, TestSize.Level1)
1219 {
1220 SLOGI("HwCastProviderSessionInit001 begin!");
1221 std::shared_ptr<HwCastProviderSession> provideSession = std::make_shared<HwCastProviderSession>(nullptr);
1222 EXPECT_EQ(provideSession != nullptr, true);
1223 provideSession->Init();
1224 SLOGI("HwCastProviderSessionInit001 end!");
1225 }
1226
1227 /**
1228 * @tc.name: HwCastProviderSessionRelease001
1229 * @tc.desc:
1230 * @tc.type: FUNC
1231 * @tc.require:
1232 */
1233 static HWTEST(HwCastTest, HwCastProviderSessionRelease001, TestSize.Level1)
1234 {
1235 SLOGI("HwCastProviderSessionRelease001 begin!");
1236 std::shared_ptr<HwCastProviderSession> provideSession = std::make_shared<HwCastProviderSession>(nullptr);
1237 EXPECT_EQ(provideSession != nullptr, true);
1238 provideSession->Init();
1239 provideSession->Release();
1240 SLOGI("HwCastProviderSessionRelease001 end!");
1241 }
1242
1243 /**
1244 * @tc.name: HwCastProviderSessionOnDeviceState001
1245 * @tc.desc:
1246 * @tc.type: FUNC
1247 * @tc.require:
1248 */
1249 static HWTEST(HwCastTest, HwCastProviderSessionOnDeviceState001, TestSize.Level1)
1250 {
1251 SLOGI("HwCastProviderSessionOnDeviceState001 begin!");
1252 std::shared_ptr<HwCastProviderSession> provideSession = std::make_shared<HwCastProviderSession>(nullptr);
1253 EXPECT_EQ(provideSession != nullptr, true);
1254 provideSession->Init();
1255 OHOS::CastEngine::DeviceStateInfo stateInfo;
1256 stateInfo.deviceId = "testDeviceId";
1257 provideSession->OnDeviceState(stateInfo);
1258 SLOGI("HwCastProviderSessionOnDeviceState001 end!");
1259 }
1260
1261 /**
1262 * @tc.name: HwCastProviderSessionAddDevice001
1263 * @tc.desc:
1264 * @tc.type: FUNC
1265 * @tc.require:
1266 */
1267 static HWTEST(HwCastTest, HwCastProviderSessionAddDevice001, TestSize.Level1)
1268 {
1269 SLOGI("HwCastProviderSessionAddDevice001 begin!");
1270 std::shared_ptr<HwCastProviderSession> provideSession = std::make_shared<HwCastProviderSession>(nullptr);
1271 EXPECT_EQ(provideSession != nullptr, true);
1272 provideSession->Init();
1273 std::string deviceId = "deviceId";
1274 EXPECT_EQ(provideSession->AddDevice(deviceId), false);
1275 SLOGI("HwCastProviderSessionAddDevice001 end!");
1276 }
1277
1278 /**
1279 * @tc.name: HwCastProviderSessionRemoveDevice001
1280 * @tc.desc:
1281 * @tc.type: FUNC
1282 * @tc.require:
1283 */
1284 static HWTEST(HwCastTest, HwCastProviderSessionRemoveDevice001, TestSize.Level1)
1285 {
1286 SLOGI("HwCastProviderSessionRemoveDevice001 begin!");
1287 std::shared_ptr<HwCastProviderSession> provideSession = std::make_shared<HwCastProviderSession>(nullptr);
1288 EXPECT_EQ(provideSession != nullptr, true);
1289 provideSession->Init();
1290 std::string deviceId = "deviceId";
1291 EXPECT_EQ(provideSession->RemoveDevice(deviceId), false);
1292 SLOGI("HwCastProviderSessionRemoveDevice001 end!");
1293 }
1294
1295 /**
1296 * @tc.name: HwCastProviderSessionCreateStreamPlayer001
1297 * @tc.desc:
1298 * @tc.type: FUNC
1299 * @tc.require:
1300 */
1301 static HWTEST(HwCastTest, HwCastProviderSessionCreateStreamPlayer001, TestSize.Level1)
1302 {
1303 SLOGI("HwCastProviderSessionCreateStreamPlayer001 begin!");
1304 std::shared_ptr<HwCastProviderSession> provideSession = std::make_shared<HwCastProviderSession>(nullptr);
1305 EXPECT_EQ(provideSession != nullptr, true);
1306 provideSession->Init();
1307 EXPECT_EQ(provideSession->CreateStreamPlayer(), nullptr);
1308 SLOGI("HwCastProviderSessionCreateStreamPlayer001 end!");
1309 }
1310
1311 /**
1312 * @tc.name: HwCastProviderSessionRegisterCastSessionStateListener001
1313 * @tc.desc:
1314 * @tc.type: FUNC
1315 * @tc.require:
1316 */
1317 static HWTEST(HwCastTest, HwCastProviderSessionRegisterCastSessionStateListener001, TestSize.Level1)
1318 {
1319 SLOGI("HwCastProviderSessionRegisterCastSessionStateListener001 begin!");
1320 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
1321 EXPECT_EQ(hwCastProvider != nullptr, true);
1322 hwCastProvider->Init();
1323 EXPECT_EQ(hwCastProvider->RegisterCastSessionStateListener(0, nullptr), false);
1324 SLOGI("HwCastProviderSessionRegisterCastSessionStateListener001 end!");
1325 }
1326
1327 /**
1328 * @tc.name: HwCastProviderSessionUnregisterCastSessionStateListener001
1329 * @tc.desc:
1330 * @tc.type: FUNC
1331 * @tc.require:
1332 */
1333 static HWTEST(HwCastTest, HwCastProviderSessionUnregisterCastSessionStateListener001, TestSize.Level1)
1334 {
1335 SLOGI("HwCastProviderSessionUnregisterCastSessionStateListener001 begin!");
1336 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
1337 EXPECT_EQ(hwCastProvider != nullptr, true);
1338 EXPECT_EQ(hwCastProvider->UnRegisterCastSessionStateListener(0, nullptr), false);
1339 SLOGI("HwCastProviderSessionUnregisterCastSessionStateListener001 end!");
1340 }
1341