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