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: ProcessMediaKeyResponse001
316  * @tc.desc: ProcessMediaKeyResponse
317  * @tc.type: FUNC
318  * @tc.require: NA
319  */
320 HWTEST_F(HwCastStreamPlayerTest, ProcessMediaKeyResponse001, TestSize.Level1)
321 {
322     SLOGI("ProcessMediaKeyResponse001 begin!");
323     std::string assetId = "assetId";
324     std::vector<uint8_t> response;
325     ASSERT_EQ(hwCastStreamPlayer->ProcessMediaKeyResponse(assetId, response), AVSESSION_SUCCESS);
326     SLOGI("ProcessMediaKeyResponse001 end!");
327 }
328 
329 /**
330  * @tc.name: RegisterControllerListener001
331  * @tc.desc: RegisterControllerListener invalid listener
332  * @tc.type: FUNC
333  * @tc.require: NA
334  */
335 HWTEST_F(HwCastStreamPlayerTest, RegisterControllerListener001, TestSize.Level1)
336 {
337     SLOGI("RegisterControllerListener001 begin!");
338     ASSERT_EQ(hwCastStreamPlayer->RegisterControllerListener(nullptr), AVSESSION_ERROR);
339     SLOGI("RegisterControllerListener001 end!");
340 }
341 
342 /**
343  * @tc.name: RegisterControllerListener002
344  * @tc.desc: RegisterControllerListener repeat
345  * @tc.type: FUNC
346  * @tc.require: NA
347  */
348 HWTEST_F(HwCastStreamPlayerTest, RegisterControllerListener002, TestSize.Level1)
349 {
350     SLOGI("RegisterControllerListener002 begin!");
351     std::shared_ptr<AVCastControllerItem> avCastControllerItem = std::make_shared<AVCastControllerItem>();
352     ASSERT_EQ(hwCastStreamPlayer->RegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
353     ASSERT_EQ(hwCastStreamPlayer->RegisterControllerListener(avCastControllerItem), AVSESSION_ERROR);
354     SLOGI("RegisterControllerListener002 end!");
355 }
356 
357 /**
358  * @tc.name: UnRegisterControllerListener001
359  * @tc.desc: UnRegisterControllerListener invalid listener
360  * @tc.type: FUNC
361  * @tc.require: NA
362  */
363 HWTEST_F(HwCastStreamPlayerTest, UnRegisterControllerListener001, TestSize.Level1)
364 {
365     SLOGI("UnRegisterControllerListener001 begin!");
366     ASSERT_EQ(hwCastStreamPlayer->UnRegisterControllerListener(nullptr), AVSESSION_ERROR);
367     SLOGI("UnRegisterControllerListener001 end!");
368 }
369 
370 /**
371  * @tc.name: UnRegisterControllerListener002
372  * @tc.desc: UnRegisterControllerListener success
373  * @tc.type: FUNC
374  * @tc.require: NA
375  */
376 HWTEST_F(HwCastStreamPlayerTest, UnRegisterControllerListener002, TestSize.Level1)
377 {
378     SLOGI("UnRegisterControllerListener002 begin!");
379     std::shared_ptr<AVCastControllerItem> avCastControllerItem = std::make_shared<AVCastControllerItem>();
380     ASSERT_EQ(hwCastStreamPlayer->RegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
381     ASSERT_EQ(hwCastStreamPlayer->UnRegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
382     SLOGI("UnRegisterControllerListener002 end!");
383 }
384 
385 /**
386  * @tc.name: UnRegisterControllerListener003
387  * @tc.desc: UnRegisterControllerListener failed
388  * @tc.type: FUNC
389  * @tc.require: NA
390  */
391 HWTEST_F(HwCastStreamPlayerTest, UnRegisterControllerListener003, TestSize.Level1)
392 {
393     SLOGI("UnRegisterControllerListener003 begin!");
394     std::shared_ptr<AVCastControllerItem> avCastControllerItem1 = std::make_shared<AVCastControllerItem>();
395     std::shared_ptr<AVCastControllerItem> avCastControllerItem2 = std::make_shared<AVCastControllerItem>();
396     ASSERT_EQ(hwCastStreamPlayer->RegisterControllerListener(avCastControllerItem1), AVSESSION_SUCCESS);
397     ASSERT_EQ(hwCastStreamPlayer->UnRegisterControllerListener(avCastControllerItem2), AVSESSION_ERROR);
398     SLOGI("UnRegisterControllerListener003 end!");
399 }
400 
401 /**
402  * @tc.name: OnStateChanged001
403  * @tc.desc: OnStateChanged
404  * @tc.type: FUNC
405  * @tc.require: NA
406  */
407 HWTEST_F(HwCastStreamPlayerTest, OnStateChanged001, TestSize.Level1)
408 {
409     SLOGI("OnStateChanged001 begin!");
410     std::shared_ptr<AVCastControllerItem> avCastControllerItem = std::make_shared<AVCastControllerItem>();
411     ASSERT_EQ(hwCastStreamPlayer->RegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
412     hwCastStreamPlayer->OnStateChanged(CastEngine::PlayerStates::PLAYER_INITIALIZED, true);
413     ASSERT_EQ(hwCastStreamPlayer->UnRegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
414     SLOGI("OnStateChanged001 end!");
415 }
416 
417 /**
418  * @tc.name: OnPositionChanged001
419  * @tc.desc: OnPositionChanged invalid
420  * @tc.type: FUNC
421  * @tc.require: NA
422  */
423 HWTEST_F(HwCastStreamPlayerTest, OnPositionChanged001, TestSize.Level1)
424 {
425     SLOGI("OnPositionChanged001 begin!");
426     std::shared_ptr<AVCastControllerItem> avCastControllerItem = std::make_shared<AVCastControllerItem>();
427     ASSERT_EQ(hwCastStreamPlayer->RegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
428     hwCastStreamPlayer->OnPositionChanged(-1, -1, -1);
429     ASSERT_EQ(hwCastStreamPlayer->UnRegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
430     SLOGI("OnPositionChanged001 end!");
431 }
432 
433 /**
434  * @tc.name: OnPositionChanged002
435  * @tc.desc: OnPositionChanged
436  * @tc.type: FUNC
437  * @tc.require: NA
438  */
439 HWTEST_F(HwCastStreamPlayerTest, OnPositionChanged002, TestSize.Level1)
440 {
441     SLOGI("OnPositionChanged002 begin!");
442     std::shared_ptr<AVCastControllerItem> avCastControllerItem = std::make_shared<AVCastControllerItem>();
443     ASSERT_EQ(hwCastStreamPlayer->RegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
444     hwCastStreamPlayer->OnPositionChanged(0, 0, 10);
445     ASSERT_EQ(hwCastStreamPlayer->UnRegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
446     SLOGI("OnPositionChanged002 end!");
447 }
448 
449 /**
450  * @tc.name: OnMediaItemChanged001
451  * @tc.desc: OnMediaItemChanged
452  * @tc.type: FUNC
453  * @tc.require: NA
454  */
455 HWTEST_F(HwCastStreamPlayerTest, OnMediaItemChanged001, TestSize.Level1)
456 {
457     SLOGI("OnMediaItemChanged001 begin!");
458     std::shared_ptr<AVCastControllerItem> avCastControllerItem = std::make_shared<AVCastControllerItem>();
459     ASSERT_EQ(hwCastStreamPlayer->RegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
460     CastEngine::MediaInfo mediaInfo;
461     hwCastStreamPlayer->OnMediaItemChanged(mediaInfo);
462     ASSERT_EQ(hwCastStreamPlayer->UnRegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
463     SLOGI("OnMediaItemChanged001 end!");
464 }
465 
466 /**
467  * @tc.name: OnNextRequest001
468  * @tc.desc: OnNextRequest
469  * @tc.type: FUNC
470  * @tc.require: NA
471  */
472 HWTEST_F(HwCastStreamPlayerTest, OnNextRequest001, TestSize.Level1)
473 {
474     SLOGI("OnNextRequest001 begin!");
475     std::shared_ptr<AVCastControllerItem> avCastControllerItem = std::make_shared<AVCastControllerItem>();
476     ASSERT_EQ(hwCastStreamPlayer->RegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
477     hwCastStreamPlayer->OnNextRequest();
478     ASSERT_EQ(hwCastStreamPlayer->UnRegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
479     SLOGI("OnNextRequest001 end!");
480 }
481 
482 /**
483  * @tc.name: OnPreviousRequest001
484  * @tc.desc: OnPreviousRequest
485  * @tc.type: FUNC
486  * @tc.require: NA
487  */
488 HWTEST_F(HwCastStreamPlayerTest, OnPreviousRequest001, TestSize.Level1)
489 {
490     SLOGI("OnPreviousRequest001 begin!");
491     std::shared_ptr<AVCastControllerItem> avCastControllerItem = std::make_shared<AVCastControllerItem>();
492     ASSERT_EQ(hwCastStreamPlayer->RegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
493     hwCastStreamPlayer->OnPreviousRequest();
494     ASSERT_EQ(hwCastStreamPlayer->UnRegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
495     SLOGI("OnPreviousRequest001 end!");
496 }
497 
498 /**
499  * @tc.name: OnVolumeChanged001
500  * @tc.desc: OnVolumeChanged
501  * @tc.type: FUNC
502  * @tc.require: NA
503  */
504 HWTEST_F(HwCastStreamPlayerTest, OnVolumeChanged001, TestSize.Level1)
505 {
506     SLOGI("OnVolumeChanged001 begin!");
507     std::shared_ptr<AVCastControllerItem> avCastControllerItem = std::make_shared<AVCastControllerItem>();
508     ASSERT_EQ(hwCastStreamPlayer->RegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
509     hwCastStreamPlayer->OnVolumeChanged(5, 15);
510     ASSERT_EQ(hwCastStreamPlayer->UnRegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
511     SLOGI("OnVolumeChanged001 end!");
512 }
513 
514 /**
515  * @tc.name: OnLoopModeChanged001
516  * @tc.desc: OnLoopModeChanged
517  * @tc.type: FUNC
518  * @tc.require: NA
519  */
520 HWTEST_F(HwCastStreamPlayerTest, OnLoopModeChanged001, TestSize.Level1)
521 {
522     SLOGI("OnLoopModeChanged001 begin!");
523     std::shared_ptr<AVCastControllerItem> avCastControllerItem = std::make_shared<AVCastControllerItem>();
524     ASSERT_EQ(hwCastStreamPlayer->RegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
525     hwCastStreamPlayer->OnLoopModeChanged(CastEngine::LoopMode::LOOP_MODE_SINGLE);
526     ASSERT_EQ(hwCastStreamPlayer->UnRegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
527     SLOGI("OnLoopModeChanged001 end!");
528 }
529 
530 /**
531  * @tc.name: OnPlaySpeedChanged001
532  * @tc.desc: OnPlaySpeedChanged
533  * @tc.type: FUNC
534  * @tc.require: NA
535  */
536 HWTEST_F(HwCastStreamPlayerTest, OnPlaySpeedChanged001, TestSize.Level1)
537 {
538     SLOGI("OnPlaySpeedChanged001 begin!");
539     std::shared_ptr<AVCastControllerItem> avCastControllerItem = std::make_shared<AVCastControllerItem>();
540     ASSERT_EQ(hwCastStreamPlayer->RegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
541     hwCastStreamPlayer->OnPlaySpeedChanged(CastEngine::PlaybackSpeed::SPEED_FORWARD_2_00_X);
542     ASSERT_EQ(hwCastStreamPlayer->UnRegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
543     SLOGI("OnPlaySpeedChanged001 end!");
544 }
545 
546 /**
547  * @tc.name: OnPlayerError001
548  * @tc.desc: OnPlayerError
549  * @tc.type: FUNC
550  * @tc.require: NA
551  */
552 HWTEST_F(HwCastStreamPlayerTest, OnPlayerError001, TestSize.Level1)
553 {
554     SLOGI("OnPlayerError001 begin!");
555     std::shared_ptr<AVCastControllerItem> avCastControllerItem = std::make_shared<AVCastControllerItem>();
556     ASSERT_EQ(hwCastStreamPlayer->RegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
557     hwCastStreamPlayer->OnPlayerError(10003, "PLAYER_ERROR");
558     ASSERT_EQ(hwCastStreamPlayer->UnRegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
559     SLOGI("OnPlayerError001 end!");
560 }
561 
562 /**
563  * @tc.name: OnSeekDone001
564  * @tc.desc: OnSeekDone
565  * @tc.type: FUNC
566  * @tc.require: NA
567  */
568 HWTEST_F(HwCastStreamPlayerTest, OnSeekDone001, TestSize.Level1)
569 {
570     SLOGI("OnSeekDone001 begin!");
571     std::shared_ptr<AVCastControllerItem> avCastControllerItem = std::make_shared<AVCastControllerItem>();
572     ASSERT_EQ(hwCastStreamPlayer->RegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
573     int32_t seekNumber = 0;
574     hwCastStreamPlayer->OnSeekDone(seekNumber);
575     ASSERT_EQ(hwCastStreamPlayer->UnRegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
576     SLOGI("OnSeekDone001 end!");
577 }
578 
579 /**
580  * @tc.name: OnVideoSizeChanged001
581  * @tc.desc: OnVideoSizeChanged
582  * @tc.type: FUNC
583  * @tc.require: NA
584  */
585 HWTEST_F(HwCastStreamPlayerTest, OnVideoSizeChanged001, TestSize.Level1)
586 {
587     SLOGI("OnVideoSizeChanged001 begin!");
588     std::shared_ptr<AVCastControllerItem> avCastControllerItem = std::make_shared<AVCastControllerItem>();
589     ASSERT_EQ(hwCastStreamPlayer->RegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
590     hwCastStreamPlayer->OnVideoSizeChanged(0, 0);
591     ASSERT_EQ(hwCastStreamPlayer->UnRegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
592     SLOGI("OnVideoSizeChanged001 end!");
593 }
594 
595 /**
596  * @tc.name: OnEndOfStream001
597  * @tc.desc: OnEndOfStream
598  * @tc.type: FUNC
599  * @tc.require: NA
600  */
601 HWTEST_F(HwCastStreamPlayerTest, OnEndOfStream001, TestSize.Level1)
602 {
603     SLOGI("OnEndOfStream001 begin!");
604     std::shared_ptr<AVCastControllerItem> avCastControllerItem = std::make_shared<AVCastControllerItem>();
605     ASSERT_EQ(hwCastStreamPlayer->RegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
606     hwCastStreamPlayer->OnEndOfStream(0);
607     ASSERT_EQ(hwCastStreamPlayer->UnRegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
608     SLOGI("OnEndOfStream001 end!");
609 }
610 
611 /**
612  * @tc.name: OnPlayRequest001
613  * @tc.desc: OnPlayRequest
614  * @tc.type: FUNC
615  * @tc.require: NA
616  */
617 HWTEST_F(HwCastStreamPlayerTest, OnPlayRequest001, TestSize.Level1)
618 {
619     SLOGI("OnPlayRequest001 begin!");
620     std::shared_ptr<AVCastControllerItem> avCastControllerItem = std::make_shared<AVCastControllerItem>();
621     ASSERT_EQ(hwCastStreamPlayer->RegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
622     CastEngine::MediaInfo mediaInfo;
623     hwCastStreamPlayer->OnPlayRequest(mediaInfo);
624     ASSERT_EQ(hwCastStreamPlayer->UnRegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
625     SLOGI("OnPlayRequest001 end!");
626 }
627 
628 /**
629  * @tc.name: OnKeyRequest001
630  * @tc.desc: OnKeyRequest
631  * @tc.type: FUNC
632  * @tc.require: NA
633  */
634 HWTEST_F(HwCastStreamPlayerTest, OnKeyRequest001, TestSize.Level1)
635 {
636     SLOGI("OnKeyRequest001 begin!");
637     std::shared_ptr<AVCastControllerItem> avCastControllerItem = std::make_shared<AVCastControllerItem>();
638     ASSERT_EQ(hwCastStreamPlayer->RegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
639     std::string assetId = "assetId";
640     std::vector<uint8_t> keyRequestData;
641     hwCastStreamPlayer->OnKeyRequest(assetId, keyRequestData);
642     ASSERT_EQ(hwCastStreamPlayer->UnRegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
643     SLOGI("OnKeyRequest001 end!");
644 }
645 
646 /**
647  * @tc.name: SetValidAbility001
648  * @tc.desc: SetValidAbility to cast
649  * @tc.type: FUNC
650  * @tc.require: NA
651  */
652 HWTEST_F(HwCastStreamPlayerTest, SetValidAbility001, TestSize.Level1)
653 {
654     SLOGI("SetValidAbility001 begin!");
655     std::vector<int32_t> validAbilityList;
656     validAbilityList.push_back(AVCastControlCommand::CAST_CONTROL_CMD_PLAY);
657     validAbilityList.push_back(AVCastControlCommand::CAST_CONTROL_CMD_PAUSE);
658     validAbilityList.push_back(AVCastControlCommand::CAST_CONTROL_CMD_STOP);
659     validAbilityList.push_back(AVCastControlCommand::CAST_CONTROL_CMD_PLAY_NEXT);
660     ASSERT_EQ(hwCastStreamPlayer->SetValidAbility(validAbilityList), AVSESSION_SUCCESS);
661     SLOGI("SetValidAbility001 end!");
662 }
663 
664 /**
665  * @tc.name: GetValidAbility001
666  * @tc.desc: GetValidAbility from cast
667  * @tc.type: FUNC
668  * @tc.require: NA
669  */
670 HWTEST_F(HwCastStreamPlayerTest, GetValidAbility001, TestSize.Level1)
671 {
672     SLOGI("GetValidAbility001 begin!");
673     std::vector<int32_t> validAbilityList;
674     ASSERT_EQ(hwCastStreamPlayer->GetValidAbility(validAbilityList), AVSESSION_SUCCESS);
675     SLOGI("GetValidAbility001 end!");
676 }
677 
678 
679 /**
680  * @tc.name: OnAvailableCapabilityChanged001
681  * @tc.desc: OnAvailableCapabilityChanged
682  * @tc.type: FUNC
683  * @tc.require: NA
684  */
685 HWTEST_F(HwCastStreamPlayerTest, OnAvailableCapabilityChanged001, TestSize.Level1)
686 {
687     SLOGI("OnAvailableCapabilityChanged001 begin!");
688     std::shared_ptr<AVCastControllerItem> avCastControllerItem = std::make_shared<AVCastControllerItem>();
689     ASSERT_EQ(hwCastStreamPlayer->RegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
690     CastEngine::StreamCapability streamCapability;
691     streamCapability.isPlaySupported = true;
692     streamCapability.isPauseSupported = true;
693     streamCapability.isStopSupported = true;
694     streamCapability.isNextSupported = true;
695     streamCapability.isPreviousSupported = true;
696     streamCapability.isSeekSupported = true;
697     hwCastStreamPlayer->OnAvailableCapabilityChanged(streamCapability);
698     ASSERT_EQ(hwCastStreamPlayer->UnRegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
699     SLOGI("OnAvailableCapabilityChanged001 end!");
700 }
701 } // namespace AVSession
702 } // namespace OHOS
703