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