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
18 #include "accesstoken_kit.h"
19 #include "nativetoken_kit.h"
20 #include "token_setproc.h"
21 #include "cast_session_manager.h"
22 #include "avcast_controller_item.h"
23 #include "avsession_errors.h"
24 #include "avsession_log.h"
25 #include "hw_cast_provider.h"
26 #include "hw_cast_stream_player.h"
27
28 using namespace testing::ext;
29 using namespace OHOS::CastEngine::CastEngineClient;
30 using namespace OHOS::CastEngine;
31
32 namespace OHOS {
33 namespace AVSession {
34 class HwCastStreamPlayerTest : public testing::TestWithParam<int> {
35 public:
36 static void SetUpTestCase();
37 static void TearDownTestCase();
38 void SetUp() override;
39 void TearDown() override;
40 std::shared_ptr<HwCastProviderSession> hwCastProviderSession = nullptr;
41 std::shared_ptr<HwCastStreamPlayer> hwCastStreamPlayer = nullptr;
42 };
43
44 class TestCastSessionManagerListener : public ICastSessionManagerListener {
45 public:
OnDeviceFound(const std::vector<CastRemoteDevice> & deviceList)46 void OnDeviceFound(const std::vector<CastRemoteDevice> &deviceList) override
47 {
48 static_cast<void>(deviceList);
49 }
OnSessionCreated(const std::shared_ptr<ICastSession> & castSession)50 void OnSessionCreated(const std::shared_ptr<ICastSession> &castSession) override
51 {
52 static_cast<void>(castSession);
53 }
OnServiceDied()54 void OnServiceDied() override {}
OnDeviceOffline(const std::string & deviceId)55 void OnDeviceOffline(const std::string &deviceId) override
56 {
57 static_cast<void>(deviceId);
58 }
59 };
60
CreateSession()61 std::shared_ptr<ICastSession> CreateSession()
62 {
63 std::shared_ptr<ICastSession> session;
64 auto listener = std::make_shared<TestCastSessionManagerListener>();
65 CastSessionManager::GetInstance().RegisterListener(listener);
66 CastSessionProperty property = {CastEngine::ProtocolType::CAST_PLUS_STREAM, CastEngine::EndType::CAST_SOURCE};
67 CastSessionManager::GetInstance().CreateCastSession(property, session);
68 return session;
69 }
70
CreateAVMediaDescription()71 std::shared_ptr<AVMediaDescription> CreateAVMediaDescription()
72 {
73 std::shared_ptr<AVMediaDescription> description = std::make_shared<AVMediaDescription>();
74 description->Reset();
75 description->SetMediaId("123");
76 description->SetTitle("Title");
77 description->SetSubtitle("SubTitle");
78 description->SetDescription("This is music description");
79 description->SetIcon(nullptr);
80 description->SetIconUri("xxxxx");
81 description->SetExtras(nullptr);
82 return description;
83 }
84
SetUpTestCase()85 void HwCastStreamPlayerTest::SetUpTestCase()
86 {}
87
TearDownTestCase()88 void HwCastStreamPlayerTest::TearDownTestCase()
89 {}
90
SetUp()91 void HwCastStreamPlayerTest::SetUp()
92 {
93 constexpr int castPermissionNum = 2;
94 const char *perms[castPermissionNum] = {
95 "ohos.permission.ACCESS_CAST_ENGINE_MIRROR",
96 "ohos.permission.ACCESS_CAST_ENGINE_STREAM",
97 };
98 NativeTokenInfoParams infoInstance = {
99 .dcapsNum = 0, // Indicates the capsbility list of the sa.
100 .permsNum = castPermissionNum,
101 .aclsNum = 0, // acls is the list of rights that can be escalated.
102 .dcaps = nullptr,
103 .perms = perms,
104 .acls = nullptr,
105 .processName = "hw_cast_stream_player_test",
106 .aplStr = "system_basic",
107 };
108 uint64_t tokenId = GetAccessTokenId(&infoInstance);
109 SetSelfTokenID(tokenId);
110 Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
111 std::shared_ptr<ICastSession> castSession = CreateSession();
112 hwCastProviderSession = std::make_shared<HwCastProviderSession>(castSession);
113 if (hwCastProviderSession) {
114 hwCastProviderSession->Init();
115 }
116 std::shared_ptr<IStreamPlayer> streamPlayer = hwCastProviderSession->CreateStreamPlayer();
117 hwCastStreamPlayer = std::make_shared<HwCastStreamPlayer>(streamPlayer);
118 if (hwCastStreamPlayer) {
119 hwCastStreamPlayer->Init();
120 }
121 }
122
TearDown()123 void HwCastStreamPlayerTest::TearDown()
124 {
125 if (hwCastProviderSession) {
126 hwCastProviderSession->Release();
127 }
128 if (hwCastStreamPlayer) {
129 hwCastStreamPlayer->Release();
130 }
131 }
132
133 INSTANTIATE_TEST_CASE_P(SendControlCommand, HwCastStreamPlayerTest, testing::Values(
134 AVCastControlCommand::CAST_CONTROL_CMD_INVALID,
135 AVCastControlCommand::CAST_CONTROL_CMD_PLAY,
136 AVCastControlCommand::CAST_CONTROL_CMD_PAUSE,
137 AVCastControlCommand::CAST_CONTROL_CMD_STOP,
138 AVCastControlCommand::CAST_CONTROL_CMD_PLAY_NEXT,
139 AVCastControlCommand::CAST_CONTROL_CMD_PLAY_PREVIOUS,
140 AVCastControlCommand::CAST_CONTROL_CMD_FAST_FORWARD,
141 AVCastControlCommand::CAST_CONTROL_CMD_REWIND,
142 AVCastControlCommand::CAST_CONTROL_CMD_SEEK,
143 AVCastControlCommand::CAST_CONTROL_CMD_SET_VOLUME,
144 AVCastControlCommand::CAST_CONTROL_CMD_SET_SPEED,
145 AVCastControlCommand::CAST_CONTROL_CMD_SET_LOOP_MODE,
146 AVCastControlCommand::CAST_CONTROL_CMD_TOGGLE_FAVORITE,
147 AVCastControlCommand::CAST_CONTROL_CMD_TOGGLE_MUTE,
148 AVCastControlCommand::CAST_CONTROL_CMD_MAX
149 ));
150
151 /**
152 * @tc.name: SendControlCommand001
153 * @tc.desc: SendControlCommand all test
154 * @tc.type: FUNC
155 * @tc.require: NA
156 */
157 HWTEST_P(HwCastStreamPlayerTest, SendControlCommand001, TestSize.Level1)
158 {
159 SLOGI("SendControlCommand001 begin!");
160 AVCastControlCommand command;
161 int32_t cmd = GetParam();
162 if (cmd == AVCastControlCommand::CAST_CONTROL_CMD_INVALID || cmd == AVCastControlCommand::CAST_CONTROL_CMD_MAX) {
163 ASSERT_EQ(command.SetCommand(cmd), ERR_INVALID_PARAM);
164 } else {
165 ASSERT_EQ(command.SetCommand(cmd), AVSESSION_SUCCESS);
166 }
167 hwCastStreamPlayer->SendControlCommand(command);
168 SLOGI("SendControlCommand001 end!");
169 }
170
171 /**
172 * @tc.name: Start001
173 * @tc.desc: start no media id and fd src
174 * @tc.type: FUNC
175 * @tc.require: NA
176 */
177 HWTEST_F(HwCastStreamPlayerTest, Start001, TestSize.Level1)
178 {
179 SLOGI("Start001 begin!");
180 std::shared_ptr<AVMediaDescription> description = CreateAVMediaDescription();
181 description->SetMediaUri("");
182 AVQueueItem avQueueItem;
183 avQueueItem.SetDescription(description);
184 auto ret = hwCastStreamPlayer->Start(avQueueItem);
185 ASSERT_EQ(ret, AVSESSION_SUCCESS);
186 SLOGI("Start001 end!");
187 }
188
189 /**
190 * @tc.name: Start002
191 * @tc.desc: start with fd src
192 * @tc.type: FUNC
193 * @tc.require: NA
194 */
195 HWTEST_F(HwCastStreamPlayerTest, Start002, TestSize.Level1)
196 {
197 SLOGI("Start002 begin!");
198 std::shared_ptr<AVMediaDescription> description = CreateAVMediaDescription();
199 description->SetMediaUri("");
200 AVFileDescriptor avFileDescriptor;
201 avFileDescriptor.fd_ = 100;
202 description->SetFdSrc(avFileDescriptor);
203 AVQueueItem avQueueItem;
204 avQueueItem.SetDescription(description);
205 auto ret = hwCastStreamPlayer->Start(avQueueItem);
206 ASSERT_EQ(ret, AVSESSION_ERROR);
207 SLOGI("Start002 end!");
208 }
209
210 /**
211 * @tc.name: Start003
212 * @tc.desc: start same media
213 * @tc.type: FUNC
214 * @tc.require: NA
215 */
216 HWTEST_F(HwCastStreamPlayerTest, Start003, TestSize.Level1)
217 {
218 SLOGI("Start003 begin!");
219 std::shared_ptr<AVMediaDescription> description = CreateAVMediaDescription();
220 description->SetMediaUri("Media url");
221 AVQueueItem avQueueItem;
222 avQueueItem.SetDescription(description);
223 auto ret = hwCastStreamPlayer->Start(avQueueItem);
224 ASSERT_EQ(ret, AVSESSION_SUCCESS);
225 hwCastStreamPlayer->Start(avQueueItem);
226 SLOGI("Start003 end!");
227 }
228
229 /**
230 * @tc.name: Prepare001
231 * @tc.desc: prepare no media id and fd src
232 * @tc.type: FUNC
233 * @tc.require: NA
234 */
235 HWTEST_F(HwCastStreamPlayerTest, Prepare001, TestSize.Level1)
236 {
237 SLOGI("Prepare001 begin!");
238 std::shared_ptr<AVMediaDescription> description = CreateAVMediaDescription();
239 description->SetMediaUri("");
240 AVQueueItem avQueueItem;
241 avQueueItem.SetDescription(description);
242 auto ret = hwCastStreamPlayer->Start(avQueueItem);
243 ASSERT_EQ(ret, AVSESSION_SUCCESS);
244 ret = hwCastStreamPlayer->Prepare(avQueueItem);
245 ASSERT_EQ(ret, AVSESSION_SUCCESS);
246 SLOGI("Prepare001 end!");
247 }
248
249 /**
250 * @tc.name: Prepare002
251 * @tc.desc: prepare with fd src
252 * @tc.type: FUNC
253 * @tc.require: NA
254 */
255 HWTEST_F(HwCastStreamPlayerTest, Prepare002, TestSize.Level1)
256 {
257 SLOGI("Prepare002 begin!");
258 std::shared_ptr<AVMediaDescription> description = CreateAVMediaDescription();
259 description->SetMediaUri("");
260 AVFileDescriptor avFileDescriptor;
261 avFileDescriptor.fd_ = 100;
262 description->SetFdSrc(avFileDescriptor);
263 AVQueueItem avQueueItem;
264 avQueueItem.SetDescription(description);
265 auto ret = hwCastStreamPlayer->Start(avQueueItem);
266 ASSERT_EQ(ret, AVSESSION_ERROR);
267 ret = hwCastStreamPlayer->Prepare(avQueueItem);
268 ASSERT_EQ(ret, AVSESSION_ERROR);
269 SLOGI("Prepare002 end!");
270 }
271
272 /**
273 * @tc.name: GetDuration001
274 * @tc.desc: GetDuration
275 * @tc.type: FUNC
276 * @tc.require: NA
277 */
278 HWTEST_F(HwCastStreamPlayerTest, GetDuration001, TestSize.Level1)
279 {
280 SLOGI("GetDuration001 begin!");
281 int32_t duration = 40000;
282 ASSERT_EQ(hwCastStreamPlayer->GetDuration(duration), AVSESSION_SUCCESS);
283 SLOGI("GetDuration001 end!");
284 }
285
286 /**
287 * @tc.name: GetCastAVPlaybackState001
288 * @tc.desc: GetCastAVPlaybackState
289 * @tc.type: FUNC
290 * @tc.require: NA
291 */
292 HWTEST_F(HwCastStreamPlayerTest, GetCastAVPlaybackState001, TestSize.Level1)
293 {
294 SLOGI("GetCastAVPlaybackState001 begin!");
295 AVPlaybackState state;
296 ASSERT_EQ(hwCastStreamPlayer->GetCastAVPlaybackState(state), AVSESSION_SUCCESS);
297 SLOGI("GetCastAVPlaybackState001 end!");
298 }
299
300 /**
301 * @tc.name: SetDisplaySurface001
302 * @tc.desc: SetDisplaySurface
303 * @tc.type: FUNC
304 * @tc.require: NA
305 */
306 HWTEST_F(HwCastStreamPlayerTest, SetDisplaySurface001, TestSize.Level1)
307 {
308 SLOGI("SetDisplaySurface001 begin!");
309 std::string surfaceId = "surfaceId";
310 ASSERT_EQ(hwCastStreamPlayer->SetDisplaySurface(surfaceId), AVSESSION_SUCCESS);
311 SLOGI("SetDisplaySurface001 end!");
312 }
313
314 /**
315 * @tc.name: RegisterControllerListener001
316 * @tc.desc: RegisterControllerListener invalid listener
317 * @tc.type: FUNC
318 * @tc.require: NA
319 */
320 HWTEST_F(HwCastStreamPlayerTest, RegisterControllerListener001, TestSize.Level1)
321 {
322 SLOGI("RegisterControllerListener001 begin!");
323 ASSERT_EQ(hwCastStreamPlayer->RegisterControllerListener(nullptr), AVSESSION_ERROR);
324 SLOGI("RegisterControllerListener001 end!");
325 }
326
327 /**
328 * @tc.name: RegisterControllerListener002
329 * @tc.desc: RegisterControllerListener repeat
330 * @tc.type: FUNC
331 * @tc.require: NA
332 */
333 HWTEST_F(HwCastStreamPlayerTest, RegisterControllerListener002, TestSize.Level1)
334 {
335 SLOGI("RegisterControllerListener002 begin!");
336 std::shared_ptr<AVCastControllerItem> avCastControllerItem = std::make_shared<AVCastControllerItem>();
337 ASSERT_EQ(hwCastStreamPlayer->RegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
338 ASSERT_EQ(hwCastStreamPlayer->RegisterControllerListener(avCastControllerItem), AVSESSION_ERROR);
339 SLOGI("RegisterControllerListener002 end!");
340 }
341
342 /**
343 * @tc.name: UnRegisterControllerListener001
344 * @tc.desc: UnRegisterControllerListener invalid listener
345 * @tc.type: FUNC
346 * @tc.require: NA
347 */
348 HWTEST_F(HwCastStreamPlayerTest, UnRegisterControllerListener001, TestSize.Level1)
349 {
350 SLOGI("UnRegisterControllerListener001 begin!");
351 ASSERT_EQ(hwCastStreamPlayer->UnRegisterControllerListener(nullptr), AVSESSION_ERROR);
352 SLOGI("UnRegisterControllerListener001 end!");
353 }
354
355 /**
356 * @tc.name: UnRegisterControllerListener002
357 * @tc.desc: UnRegisterControllerListener success
358 * @tc.type: FUNC
359 * @tc.require: NA
360 */
361 HWTEST_F(HwCastStreamPlayerTest, UnRegisterControllerListener002, TestSize.Level1)
362 {
363 SLOGI("UnRegisterControllerListener002 begin!");
364 std::shared_ptr<AVCastControllerItem> avCastControllerItem = std::make_shared<AVCastControllerItem>();
365 ASSERT_EQ(hwCastStreamPlayer->RegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
366 ASSERT_EQ(hwCastStreamPlayer->UnRegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
367 SLOGI("UnRegisterControllerListener002 end!");
368 }
369
370 /**
371 * @tc.name: UnRegisterControllerListener003
372 * @tc.desc: UnRegisterControllerListener failed
373 * @tc.type: FUNC
374 * @tc.require: NA
375 */
376 HWTEST_F(HwCastStreamPlayerTest, UnRegisterControllerListener003, TestSize.Level1)
377 {
378 SLOGI("UnRegisterControllerListener003 begin!");
379 std::shared_ptr<AVCastControllerItem> avCastControllerItem1 = std::make_shared<AVCastControllerItem>();
380 std::shared_ptr<AVCastControllerItem> avCastControllerItem2 = std::make_shared<AVCastControllerItem>();
381 ASSERT_EQ(hwCastStreamPlayer->RegisterControllerListener(avCastControllerItem1), AVSESSION_SUCCESS);
382 ASSERT_EQ(hwCastStreamPlayer->UnRegisterControllerListener(avCastControllerItem2), AVSESSION_ERROR);
383 SLOGI("UnRegisterControllerListener003 end!");
384 }
385
386 /**
387 * @tc.name: OnStateChanged001
388 * @tc.desc: OnStateChanged
389 * @tc.type: FUNC
390 * @tc.require: NA
391 */
392 HWTEST_F(HwCastStreamPlayerTest, OnStateChanged001, TestSize.Level1)
393 {
394 SLOGI("OnStateChanged001 begin!");
395 std::shared_ptr<AVCastControllerItem> avCastControllerItem = std::make_shared<AVCastControllerItem>();
396 ASSERT_EQ(hwCastStreamPlayer->RegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
397 hwCastStreamPlayer->OnStateChanged(CastEngine::PlayerStates::PLAYER_INITIALIZED, true);
398 ASSERT_EQ(hwCastStreamPlayer->UnRegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
399 SLOGI("OnStateChanged001 end!");
400 }
401
402 /**
403 * @tc.name: OnPositionChanged001
404 * @tc.desc: OnPositionChanged invalid
405 * @tc.type: FUNC
406 * @tc.require: NA
407 */
408 HWTEST_F(HwCastStreamPlayerTest, OnPositionChanged001, TestSize.Level1)
409 {
410 SLOGI("OnPositionChanged001 begin!");
411 std::shared_ptr<AVCastControllerItem> avCastControllerItem = std::make_shared<AVCastControllerItem>();
412 ASSERT_EQ(hwCastStreamPlayer->RegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
413 hwCastStreamPlayer->OnPositionChanged(-1, -1, -1);
414 ASSERT_EQ(hwCastStreamPlayer->UnRegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
415 SLOGI("OnPositionChanged001 end!");
416 }
417
418 /**
419 * @tc.name: OnPositionChanged002
420 * @tc.desc: OnPositionChanged
421 * @tc.type: FUNC
422 * @tc.require: NA
423 */
424 HWTEST_F(HwCastStreamPlayerTest, OnPositionChanged002, TestSize.Level1)
425 {
426 SLOGI("OnPositionChanged002 begin!");
427 std::shared_ptr<AVCastControllerItem> avCastControllerItem = std::make_shared<AVCastControllerItem>();
428 ASSERT_EQ(hwCastStreamPlayer->RegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
429 hwCastStreamPlayer->OnPositionChanged(0, 0, 10);
430 ASSERT_EQ(hwCastStreamPlayer->UnRegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
431 SLOGI("OnPositionChanged002 end!");
432 }
433
434 /**
435 * @tc.name: OnMediaItemChanged001
436 * @tc.desc: OnMediaItemChanged
437 * @tc.type: FUNC
438 * @tc.require: NA
439 */
440 HWTEST_F(HwCastStreamPlayerTest, OnMediaItemChanged001, TestSize.Level1)
441 {
442 SLOGI("OnMediaItemChanged001 begin!");
443 std::shared_ptr<AVCastControllerItem> avCastControllerItem = std::make_shared<AVCastControllerItem>();
444 ASSERT_EQ(hwCastStreamPlayer->RegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
445 CastEngine::MediaInfo mediaInfo;
446 hwCastStreamPlayer->OnMediaItemChanged(mediaInfo);
447 ASSERT_EQ(hwCastStreamPlayer->UnRegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
448 SLOGI("OnMediaItemChanged001 end!");
449 }
450
451 /**
452 * @tc.name: OnNextRequest001
453 * @tc.desc: OnNextRequest
454 * @tc.type: FUNC
455 * @tc.require: NA
456 */
457 HWTEST_F(HwCastStreamPlayerTest, OnNextRequest001, TestSize.Level1)
458 {
459 SLOGI("OnNextRequest001 begin!");
460 std::shared_ptr<AVCastControllerItem> avCastControllerItem = std::make_shared<AVCastControllerItem>();
461 ASSERT_EQ(hwCastStreamPlayer->RegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
462 hwCastStreamPlayer->OnNextRequest();
463 ASSERT_EQ(hwCastStreamPlayer->UnRegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
464 SLOGI("OnNextRequest001 end!");
465 }
466
467 /**
468 * @tc.name: OnPreviousRequest001
469 * @tc.desc: OnPreviousRequest
470 * @tc.type: FUNC
471 * @tc.require: NA
472 */
473 HWTEST_F(HwCastStreamPlayerTest, OnPreviousRequest001, TestSize.Level1)
474 {
475 SLOGI("OnPreviousRequest001 begin!");
476 std::shared_ptr<AVCastControllerItem> avCastControllerItem = std::make_shared<AVCastControllerItem>();
477 ASSERT_EQ(hwCastStreamPlayer->RegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
478 hwCastStreamPlayer->OnPreviousRequest();
479 ASSERT_EQ(hwCastStreamPlayer->UnRegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
480 SLOGI("OnPreviousRequest001 end!");
481 }
482
483 /**
484 * @tc.name: OnVolumeChanged001
485 * @tc.desc: OnVolumeChanged
486 * @tc.type: FUNC
487 * @tc.require: NA
488 */
489 HWTEST_F(HwCastStreamPlayerTest, OnVolumeChanged001, TestSize.Level1)
490 {
491 SLOGI("OnVolumeChanged001 begin!");
492 std::shared_ptr<AVCastControllerItem> avCastControllerItem = std::make_shared<AVCastControllerItem>();
493 ASSERT_EQ(hwCastStreamPlayer->RegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
494 hwCastStreamPlayer->OnVolumeChanged(5, 15);
495 ASSERT_EQ(hwCastStreamPlayer->UnRegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
496 SLOGI("OnVolumeChanged001 end!");
497 }
498
499 /**
500 * @tc.name: OnLoopModeChanged001
501 * @tc.desc: OnLoopModeChanged
502 * @tc.type: FUNC
503 * @tc.require: NA
504 */
505 HWTEST_F(HwCastStreamPlayerTest, OnLoopModeChanged001, TestSize.Level1)
506 {
507 SLOGI("OnLoopModeChanged001 begin!");
508 std::shared_ptr<AVCastControllerItem> avCastControllerItem = std::make_shared<AVCastControllerItem>();
509 ASSERT_EQ(hwCastStreamPlayer->RegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
510 hwCastStreamPlayer->OnLoopModeChanged(CastEngine::LoopMode::LOOP_MODE_SINGLE);
511 ASSERT_EQ(hwCastStreamPlayer->UnRegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
512 SLOGI("OnLoopModeChanged001 end!");
513 }
514
515 /**
516 * @tc.name: OnPlaySpeedChanged001
517 * @tc.desc: OnPlaySpeedChanged
518 * @tc.type: FUNC
519 * @tc.require: NA
520 */
521 HWTEST_F(HwCastStreamPlayerTest, OnPlaySpeedChanged001, TestSize.Level1)
522 {
523 SLOGI("OnPlaySpeedChanged001 begin!");
524 std::shared_ptr<AVCastControllerItem> avCastControllerItem = std::make_shared<AVCastControllerItem>();
525 ASSERT_EQ(hwCastStreamPlayer->RegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
526 hwCastStreamPlayer->OnPlaySpeedChanged(CastEngine::PlaybackSpeed::SPEED_FORWARD_2_00_X);
527 ASSERT_EQ(hwCastStreamPlayer->UnRegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
528 SLOGI("OnPlaySpeedChanged001 end!");
529 }
530
531 /**
532 * @tc.name: OnPlayerError001
533 * @tc.desc: OnPlayerError
534 * @tc.type: FUNC
535 * @tc.require: NA
536 */
537 HWTEST_F(HwCastStreamPlayerTest, OnPlayerError001, TestSize.Level1)
538 {
539 SLOGI("OnPlayerError001 begin!");
540 std::shared_ptr<AVCastControllerItem> avCastControllerItem = std::make_shared<AVCastControllerItem>();
541 ASSERT_EQ(hwCastStreamPlayer->RegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
542 hwCastStreamPlayer->OnPlayerError(10003, "PLAYER_ERROR");
543 ASSERT_EQ(hwCastStreamPlayer->UnRegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
544 SLOGI("OnPlayerError001 end!");
545 }
546
547 /**
548 * @tc.name: OnSeekDone001
549 * @tc.desc: OnSeekDone
550 * @tc.type: FUNC
551 * @tc.require: NA
552 */
553 HWTEST_F(HwCastStreamPlayerTest, OnSeekDone001, TestSize.Level1)
554 {
555 SLOGI("OnSeekDone001 begin!");
556 std::shared_ptr<AVCastControllerItem> avCastControllerItem = std::make_shared<AVCastControllerItem>();
557 ASSERT_EQ(hwCastStreamPlayer->RegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
558 int32_t seekNumber = 0;
559 hwCastStreamPlayer->OnSeekDone(seekNumber);
560 ASSERT_EQ(hwCastStreamPlayer->UnRegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
561 SLOGI("OnSeekDone001 end!");
562 }
563
564 /**
565 * @tc.name: OnVideoSizeChanged001
566 * @tc.desc: OnVideoSizeChanged
567 * @tc.type: FUNC
568 * @tc.require: NA
569 */
570 HWTEST_F(HwCastStreamPlayerTest, OnVideoSizeChanged001, TestSize.Level1)
571 {
572 SLOGI("OnVideoSizeChanged001 begin!");
573 std::shared_ptr<AVCastControllerItem> avCastControllerItem = std::make_shared<AVCastControllerItem>();
574 ASSERT_EQ(hwCastStreamPlayer->RegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
575 hwCastStreamPlayer->OnVideoSizeChanged(0, 0);
576 ASSERT_EQ(hwCastStreamPlayer->UnRegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
577 SLOGI("OnVideoSizeChanged001 end!");
578 }
579
580 /**
581 * @tc.name: OnEndOfStream001
582 * @tc.desc: OnEndOfStream
583 * @tc.type: FUNC
584 * @tc.require: NA
585 */
586 HWTEST_F(HwCastStreamPlayerTest, OnEndOfStream001, TestSize.Level1)
587 {
588 SLOGI("OnEndOfStream001 begin!");
589 std::shared_ptr<AVCastControllerItem> avCastControllerItem = std::make_shared<AVCastControllerItem>();
590 ASSERT_EQ(hwCastStreamPlayer->RegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
591 hwCastStreamPlayer->OnEndOfStream(0);
592 ASSERT_EQ(hwCastStreamPlayer->UnRegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
593 SLOGI("OnEndOfStream001 end!");
594 }
595
596 /**
597 * @tc.name: OnPlayRequest001
598 * @tc.desc: OnPlayRequest
599 * @tc.type: FUNC
600 * @tc.require: NA
601 */
602 HWTEST_F(HwCastStreamPlayerTest, OnPlayRequest001, TestSize.Level1)
603 {
604 SLOGI("OnPlayRequest001 begin!");
605 std::shared_ptr<AVCastControllerItem> avCastControllerItem = std::make_shared<AVCastControllerItem>();
606 ASSERT_EQ(hwCastStreamPlayer->RegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
607 CastEngine::MediaInfo mediaInfo;
608 hwCastStreamPlayer->OnPlayRequest(mediaInfo);
609 ASSERT_EQ(hwCastStreamPlayer->UnRegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
610 SLOGI("OnPlayRequest001 end!");
611 }
612 } // namespace AVSession
613 } // namespace OHOS
614