1 /*
2 * Copyright (c) 2024 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 "media_errors.h"
17 #include "hiplayer_impl_unit_test.h"
18 #include "pipeline/pipeline.h"
19 #include "player.h"
20
21 namespace OHOS {
22 namespace Media {
23 using namespace std;
24 using namespace testing::ext;
25
26 namespace {
27 const int64_t PLAY_RANGE_DEFAULT_VALUE = -1; // play range default value.
28 const std::string MEDIA_ROOT = "file:///data/test/";
29 const std::string VIDEO_FILE1 = MEDIA_ROOT + "H264_AAC.mp4";
30 const std::string TOTAL_MEMORY_SIZE = "TOTAL_MEMORY_SIZE";
31 }
32
SetUpTestCase(void)33 void HiplayerImplUnitTest::SetUpTestCase(void)
34 {
35 }
36
TearDownTestCase(void)37 void HiplayerImplUnitTest::TearDownTestCase(void)
38 {
39 }
40
SetUp(void)41 void HiplayerImplUnitTest::SetUp(void)
42 {
43 hiplayer_ = std::make_unique<HiPlayerImpl>(0, 0, 0, 0);
44 }
45
TearDown(void)46 void HiplayerImplUnitTest::TearDown(void)
47 {
48 hiplayer_ = nullptr;
49 }
50
51 /**
52 * @tc.name : Test GetRealPath API
53 * @tc.number : GetRealPath_001
54 * @tc.desc : Test GetRealPath interface, set url to "file://".
55 * @tc.require : issueI5NZAQ
56 */
57 HWTEST_F(HiplayerImplUnitTest, GetRealPath_001, TestSize.Level0)
58 {
59 // 1. Set up the test environment
60 std::string url = "file://";
61 std::string realUrlPath;
62
63 // 2. Call the function to be tested
64 int32_t ret = hiplayer_->GetRealPath(url, realUrlPath);
65
66 // 3. Verify the result
67 EXPECT_EQ(ret, MSERR_OPEN_FILE_FAILED);
68 }
69
70 /**
71 * @tc.name : Test GetRealPath API
72 * @tc.number : GetRealPath_002
73 * @tc.desc : Test GetRealPath interface, set url to "file".
74 * @tc.require : issueI5NZAQ
75 */
76 HWTEST_F(HiplayerImplUnitTest, GetRealPath_002, TestSize.Level0)
77 {
78 // 1. Set up the test environment
79 std::string url = "file";
80 std::string realUrlPath;
81
82 // 2. Call the function to be tested
83 int32_t ret = hiplayer_->GetRealPath(url, realUrlPath);
84
85 // 3. Verify the result
86 EXPECT_EQ(ret, MSERR_OPEN_FILE_FAILED);
87 }
88
89 /**
90 * @tc.name : Test GetRealPath API
91 * @tc.number : GetRealPath_003
92 * @tc.desc : Test GetRealPath interface, set url to "file:///storage/../test.mp3".
93 * @tc.require : issueI5NZAQ
94 */
95 HWTEST_F(HiplayerImplUnitTest, GetRealPath_003, TestSize.Level0)
96 {
97 // 1. Set up the test environment
98 std::string url = "file:///storage/../test.mp3";
99 std::string realUrlPath;
100
101 // 2. Call the function to be tested
102 int32_t ret = hiplayer_->GetRealPath(url, realUrlPath);
103
104 // 3. Verify the result
105 EXPECT_EQ(ret, MSERR_FILE_ACCESS_FAILED);
106 }
107
108 /**
109 * @tc.name : Test SetSource API
110 * @tc.number : SetSource_001
111 * @tc.desc : Test SetSource interface, set uri to "".
112 * @tc.require : issueI5NZAQ
113 */
114 HWTEST_F(HiplayerImplUnitTest, SetSource_001, TestSize.Level0)
115 {
116 // 1. Set up the test environment
117 std::string uri = "";
118
119 // 2. Call the function to be tested
120 int32_t result = hiplayer_->SetSource(uri);
121
122 // 3. Verify the result
123 EXPECT_EQ(result, MSERR_OPEN_FILE_FAILED);
124 }
125
126 /**
127 * @tc.name : Test SetSource API
128 * @tc.number : SetSource_002
129 * @tc.desc : Test SetSource interface, set uri to "file://".
130 * @tc.require : issueI5NZAQ
131 */
132 HWTEST_F(HiplayerImplUnitTest, SetSource_002, TestSize.Level0)
133 {
134 // 1. Set up the test environment
135 std::string uri = "file://";
136
137 // 2. Call the function to be tested
138 int32_t result = hiplayer_->SetSource(uri);
139
140 // 3. Verify the result
141 EXPECT_EQ(result, MSERR_OPEN_FILE_FAILED);
142 }
143
144 /**
145 * @tc.name : Test SetSource API
146 * @tc.number : SetSource_003
147 * @tc.desc : Test SetSource interface, set uri to "http://".
148 * @tc.require : issueI5NZAQ
149 */
150 HWTEST_F(HiplayerImplUnitTest, SetSource_003, TestSize.Level0)
151 {
152 // 1. Set up the test environment
153 std::string uri = "http://";
154
155 // 2. Call the function to be tested
156 int32_t result = hiplayer_->SetSource(uri);
157
158 // 3. Verify the result
159 EXPECT_EQ(result, MSERR_OK);
160 }
161
162 /**
163 * @tc.name : Test SetSource API
164 * @tc.number : SetSource_004
165 * @tc.desc : Test SetSource interface, set uri to "https://".
166 * @tc.require : issueI5NZAQ
167 */
168 HWTEST_F(HiplayerImplUnitTest, SetSource_004, TestSize.Level0)
169 {
170 // 1. Set up the test environment
171 std::string uri = "https://";
172
173 // 2. Call the function to be tested
174 int32_t result = hiplayer_->SetSource(uri);
175
176 // 3. Verify the result
177 EXPECT_EQ(result, MSERR_OK);
178 }
179
180 /**
181 * @tc.name : Test SetSource API
182 * @tc.number : SetSource_005
183 * @tc.desc : Test SetSource interface, set uri to "invalid".
184 * @tc.require : issueI5NZAQ
185 */
186 HWTEST_F(HiplayerImplUnitTest, SetSource_005, TestSize.Level0)
187 {
188 // 1. Set up the test environment
189 std::string uri = "invalid";
190
191 // 2. Call the function to be tested
192 int32_t result = hiplayer_->SetSource(uri);
193
194 // 3. Verify the result
195 EXPECT_EQ(result, MSERR_OPEN_FILE_FAILED);
196 }
197
198 /**
199 * @tc.name : Test SetMediaSource API
200 * @tc.number : SetMediaSource_001
201 * @tc.desc : Test SetMediaSource interface, set mediaSource to nullptr.
202 * @tc.require : issueI5NZAQ
203 */
204 HWTEST_F(HiplayerImplUnitTest, SetMediaSource_001, TestSize.Level0)
205 {
206 // 1. Set up the test environment
207 std::shared_ptr<AVMediaSource> mediaSource = nullptr;
208 AVPlayStrategy strategy;
209
210 // 2. Call the function to be tested
211 int32_t ret = hiplayer_->SetMediaSource(mediaSource, strategy);
212
213 // 3. Verify the result
214 EXPECT_EQ(ret, MSERR_INVALID_VAL);
215 }
216
217 /**
218 * @tc.name : Test SetMediaSource API
219 * @tc.number : SetMediaSource_002
220 * @tc.desc : Test SetMediaSource interface, set url to file url.
221 * @tc.require : issueI5NZAQ
222 */
223 HWTEST_F(HiplayerImplUnitTest, SetMediaSource_002, TestSize.Level0)
224 {
225 // 1. Set up the test environment
226 std::map<std::string, std::string> sourceHeader;
227 std::shared_ptr<AVMediaSource> mediaSource = std::make_shared<AVMediaSource>("/storage/test.mp3", sourceHeader);
228 AVPlayStrategy strategy;
229
230 // 2. Call the function to be tested
231 int32_t ret = hiplayer_->SetMediaSource(mediaSource, strategy);
232
233 // 3. Verify the result
234 EXPECT_EQ(ret, MSERR_OPEN_FILE_FAILED);
235 }
236
237 /**
238 * @tc.name : Test SetMediaSource API
239 * @tc.number : SetMediaSource_003
240 * @tc.desc : Test SetMediaSource interface, set url to http url.
241 * @tc.require : issueI5NZAQ
242 */
243 HWTEST_F(HiplayerImplUnitTest, SetMediaSource_003, TestSize.Level0)
244 {
245 // 1. Set up the test environment
246 std::map<std::string, std::string> sourceHeader;
247 std::shared_ptr<AVMediaSource> mediaSource = std::make_shared<AVMediaSource>("http://test.mp3", sourceHeader);
248 AVPlayStrategy strategy;
249
250 // 2. Call the function to be tested
251 int32_t ret = hiplayer_->SetMediaSource(mediaSource, strategy);
252
253 // 3. Verify the result
254 EXPECT_EQ(ret, MSERR_OK);
255 }
256
257 /**
258 * @tc.name : Test SetMediaSource API
259 * @tc.number : SetMediaSource_004
260 * @tc.desc : Test SetMediaSource interface, set mimeType to AVMimeTypes::APPLICATION_M3U8.
261 * @tc.require : issueI5NZAQ
262 */
263 HWTEST_F(HiplayerImplUnitTest, SetMediaSource_004, TestSize.Level0)
264 {
265 // 1. Set up the test environment
266 std::map<std::string, std::string> sourceHeader;
267 std::shared_ptr<AVMediaSource> mediaSource = std::make_shared<AVMediaSource>("http://test.mp3", sourceHeader);
268 mediaSource->mimeType_ = AVMimeTypes::APPLICATION_M3U8;
269 AVPlayStrategy strategy;
270
271 // 2. Call the function to be tested
272 int32_t ret = hiplayer_->SetMediaSource(mediaSource, strategy);
273
274 // 3. Verify the result
275 EXPECT_EQ(ret, MSERR_OK);
276 }
277
278 /**
279 * @tc.name : Test SetMediaSource API
280 * @tc.number : SetMediaSource_005
281 * @tc.desc : Test SetMediaSource interface, enable super resolution
282 * @tc.require : issueI5NZAQ
283 */
284 HWTEST_F(HiplayerImplUnitTest, SetMediaSource_005, TestSize.Level0)
285 {
286 // 1. Set up the test environment
287 std::map<std::string, std::string> sourceHeader;
288 std::shared_ptr<AVMediaSource> mediaSource = std::make_shared<AVMediaSource>("http://test.mp3", sourceHeader);
289 AVPlayStrategy strategy;
290 strategy.enableSuperResolution = true;
291
292 // 2. Call the function to be tested
293 int32_t ret = hiplayer_->SetMediaSource(mediaSource, strategy);
294
295 // 3. Verify the result
296 EXPECT_EQ(ret, MSERR_OK);
297 EXPECT_EQ(hiplayer_->videoPostProcessorType_, VideoPostProcessorType::SUPER_RESOLUTION);
298 EXPECT_EQ(hiplayer_->isPostProcessorOn_, true);
299 }
300
301 /**
302 * @tc.name : Test ResetIfSourceExisted API
303 * @tc.number : ResetIfSourceExisted_001
304 * @tc.desc : Test ResetIfSourceExisted interface, pipeline is not nullptr.
305 * @tc.require : issueI5NZAQ
306 */
307 HWTEST_F(HiplayerImplUnitTest, ResetIfSourceExisted_001, TestSize.Level0)
308 {
309 // 1. Set up the test environment
310 hiplayer_->demuxer_ = FilterFactory::Instance().CreateFilter<DemuxerFilter>("builtin.player.demuxer",
311 FilterType::FILTERTYPE_DEMUXER);
312
313 // 2. Call the function to be tested
314 hiplayer_->ResetIfSourceExisted();
315
316 // 3. Verify the result
317 EXPECT_NE(hiplayer_->pipeline_, nullptr);
318 EXPECT_EQ(hiplayer_->audioDecoder_, nullptr);
319 }
320
321 /**
322 * @tc.name : Test ResetIfSourceExisted API
323 * @tc.number : ResetIfSourceExisted_002
324 * @tc.desc : Test ResetIfSourceExisted interface, audioDecoder is not nullptr.
325 * @tc.require : issueI5NZAQ
326 */
327 HWTEST_F(HiplayerImplUnitTest, ResetIfSourceExisted_002, TestSize.Level0)
328 {
329 // 1. Set up the test environment
330 hiplayer_->demuxer_ = FilterFactory::Instance().CreateFilter<DemuxerFilter>("builtin.player.demuxer",
331 FilterType::FILTERTYPE_DEMUXER);
332 hiplayer_->audioDecoder_ = FilterFactory::Instance().CreateFilter<AudioDecoderFilter>("player.audiodecoder",
333 FilterType::FILTERTYPE_ADEC);
334
335 hiplayer_->audioDecoder_->decoder_ = std::make_shared<AudioDecoderAdapter>();
336 // 2. Call the function to be tested
337 hiplayer_->ResetIfSourceExisted();
338
339 // 3. Verify the result
340 EXPECT_NE(hiplayer_->pipeline_, nullptr);
341 EXPECT_EQ(hiplayer_->audioDecoder_, nullptr);
342 }
343
344 /**
345 * @tc.name : Test BreakIfInterruptted API
346 * @tc.number : BreakIfInterruptted_001
347 * @tc.desc : Test ResetIfSourceExisted interface, return true.
348 * @tc.require : issueI5NZAQ
349 */
350 HWTEST_F(HiplayerImplUnitTest, BreakIfInterruptted_001, TestSize.Level0)
351 {
352 // 1. Set up the test environment
353 hiplayer_->isInterruptNeeded_ = true;
354
355 // 2. Call the function to be tested
356 bool ret = hiplayer_->BreakIfInterruptted();
357
358 // 3. Verify the result
359 EXPECT_EQ(ret, true);
360 }
361
362 /**
363 * @tc.name : Test SetInterruptState API
364 * @tc.number : SetInterruptState_001
365 * @tc.desc : Test SetInterruptState interface, isInterruptNeeded_ is false.
366 * @tc.require : issueI5NZAQ
367 */
368 HWTEST_F(HiplayerImplUnitTest, SetInterruptState_001, TestSize.Level0)
369 {
370 // 1. Set up the test environment
371 bool isInterruptNeeded = false;
372
373 // 2. Call the function to be tested
374 hiplayer_->SetInterruptState(isInterruptNeeded);
375
376 // 3. Verify the result
377 EXPECT_EQ(hiplayer_->isInterruptNeeded_, false);
378 }
379
380 /**
381 * @tc.name : Test SetInterruptState API
382 * @tc.number : SetInterruptState_002
383 * @tc.desc : Test SetInterruptState interface, isInterruptNeeded_ is true.
384 * @tc.require : issueI5NZAQ
385 */
386 HWTEST_F(HiplayerImplUnitTest, SetInterruptState_002, TestSize.Level0)
387 {
388 // 1. Set up the test environment
389 bool isInterruptNeeded = true;
390
391 std::string name = "builtin.player.demuxer";
392 std::shared_ptr<DemuxerFilterMock> demuxerMock =
393 std::make_shared<DemuxerFilterMock>(name, FilterType::FILTERTYPE_DEMUXER);
394 hiplayer_->demuxer_ = demuxerMock;
395
396 hiplayer_->seekAgent_ = std::make_shared<SeekAgent>(demuxerMock);
397
398 // 2. Call the function to be tested
399 hiplayer_->SetInterruptState(isInterruptNeeded);
400
401 // 3. Verify the result
402 EXPECT_EQ(hiplayer_->isInterruptNeeded_, true);
403 EXPECT_NE(hiplayer_->demuxer_, nullptr);
404 EXPECT_NE(hiplayer_->seekAgent_, nullptr);
405 }
406
407 /**
408 * @tc.name : Test SetInterruptState API
409 * @tc.number : SetInterruptState_003
410 * @tc.desc : Test SetInterruptState interface, interruptMonitor_ exist.
411 * @tc.require : issueI5NZAQ
412 */
413 HWTEST_F(HiplayerImplUnitTest, SetInterruptState_003, TestSize.Level0)
414 {
415 bool isInterruptNeeded = false;
416 hiplayer_->interruptMonitor_ = std::make_shared<InterruptMonitor>();
417
418 hiplayer_->SetInterruptState(isInterruptNeeded);
419 EXPECT_EQ(hiplayer_->isInterruptNeeded_, false);
420 isInterruptNeeded = true;
421 hiplayer_->SetInterruptState(isInterruptNeeded);
422 EXPECT_EQ(hiplayer_->isInterruptNeeded_, true);
423 }
424
425 /**
426 * @tc.name : Test DoInitializeForHttp API
427 * @tc.number : DoInitializeForHttp_001
428 * @tc.desc : Test DoInitializeForHttp interface, isNetWorkPlay_ is false.
429 * @tc.require : issueI5NZAQ
430 */
431 HWTEST_F(HiplayerImplUnitTest, DoInitializeForHttp_001, TestSize.Level0)
432 {
433 // 1. Set up the test environment
434 hiplayer_->isNetWorkPlay_ = false;
435
436 // 2. Call the function to be tested
437 hiplayer_->DoInitializeForHttp();
438
439 // 3. Verify the result
440 EXPECT_EQ(hiplayer_->isNetWorkPlay_, false);
441 }
442
443 /**
444 * @tc.name : Test DoInitializeForHttp API
445 * @tc.number : DoInitializeForHttp_002
446 * @tc.desc : Test DoInitializeForHttp interface, GetBitRates return OK and vBitRates is not empty.
447 * @tc.require : issueI5NZAQ
448 */
449 HWTEST_F(HiplayerImplUnitTest, DoInitializeForHttp_002, TestSize.Level0)
450 {
451 // 1. Set up the test environment
452 hiplayer_->isNetWorkPlay_ = true;
453 std::string name = "builtin.player.demuxer";
454 std::shared_ptr<DemuxerFilterMock> demuxerMock =
455 std::make_shared<DemuxerFilterMock>(name, FilterType::FILTERTYPE_DEMUXER);
456 hiplayer_->demuxer_ = demuxerMock;
457 demuxerMock->pushData_ = true;
458
459 // 2. Call the function to be tested
460 hiplayer_->DoInitializeForHttp();
461
462 // 3. Verify the result
463 EXPECT_EQ(hiplayer_->isNetWorkPlay_, true);
464 }
465
466 /**
467 * @tc.name : Test DoInitializeForHttp API
468 * @tc.number : DoInitializeForHttp_003
469 * @tc.desc : Test DoInitializeForHttp interface, GetBitRates return not OK or vBitRates is empty.
470 * @tc.require : issueI5NZAQ
471 */
472 HWTEST_F(HiplayerImplUnitTest, DoInitializeForHttp_003, TestSize.Level0)
473 {
474 // 1. Set up the test environment
475 hiplayer_->isNetWorkPlay_ = true;
476 std::string name = "builtin.player.demuxer";
477 std::shared_ptr<DemuxerFilterMock> demuxerMock =
478 std::make_shared<DemuxerFilterMock>(name, FilterType::FILTERTYPE_DEMUXER);
479 hiplayer_->demuxer_ = demuxerMock;
480 demuxerMock->getBitRatesStatus_ = Status::ERROR_UNKNOWN;
481
482 // 2. Call the function to be tested
483 hiplayer_->DoInitializeForHttp();
484
485 // 3. Verify the result
486 EXPECT_EQ(hiplayer_->isNetWorkPlay_, true);
487 }
488
489 /**
490 * @tc.name : Test DoInitializeForHttp API
491 * @tc.number : DoInitializeForHttp_004
492 * @tc.desc : Test DoInitializeForHttp interface, vBitRates is empty.
493 * @tc.require : issueI5NZAQ
494 */
495 HWTEST_F(HiplayerImplUnitTest, DoInitializeForHttp_004, TestSize.Level0)
496 {
497 // 1. Set up the test environment
498 hiplayer_->isNetWorkPlay_ = true;
499 std::string name = "builtin.player.demuxer";
500 std::shared_ptr<DemuxerFilterMock> demuxerMock =
501 std::make_shared<DemuxerFilterMock>(name, FilterType::FILTERTYPE_DEMUXER);
502 hiplayer_->demuxer_ = demuxerMock;
503 demuxerMock->pushData_ = false;
504
505 // 2. Call the function to be tested
506 hiplayer_->DoInitializeForHttp();
507
508 // 3. Verify the result
509 EXPECT_EQ(hiplayer_->isNetWorkPlay_, true);
510 }
511
512 /**
513 * @tc.name : Test Play API
514 * @tc.number : Play_001
515 * @tc.desc : Test Play interface, pipelineStates_ is PLAYER_PLAYBACK_COMPLETE.
516 * @tc.require : issueI5NZAQ
517 */
518 HWTEST_F(HiplayerImplUnitTest, Play_001, TestSize.Level0)
519 {
520 // 1. Set up the test environment
521 hiplayer_->pipelineStates_ = PlayerStates::PLAYER_PLAYBACK_COMPLETE;
522 hiplayer_->isStreaming_ = false;
523 hiplayer_->playRangeStartTime_ = 100;
524 hiplayer_->playRangeEndTime_ = 200;
525
526 // 2. Call the function to be tested
527 int32_t ret = hiplayer_->Play();
528
529 // 3. Verify the result
530 EXPECT_EQ(ret, MSERR_INVALID_OPERATION);
531 EXPECT_EQ(hiplayer_->isStreaming_, false);
532 }
533
534 /**
535 * @tc.name : Test Play API
536 * @tc.number : Play_002
537 * @tc.desc : Test Play interface, pipelineStates_ is PLAYER_PAUSED.
538 * @tc.require : issueI5NZAQ
539 */
540 HWTEST_F(HiplayerImplUnitTest, Play_002, TestSize.Level0)
541 {
542 // 1. Set up the test environment
543 hiplayer_->pipelineStates_ = PlayerStates::PLAYER_PAUSED;
544 hiplayer_->isStreaming_ = false;
545 hiplayer_->playRangeStartTime_ = 100;
546 hiplayer_->playRangeEndTime_ = 200;
547
548 // 2. Call the function to be tested
549 int32_t ret = hiplayer_->Play();
550
551 // 3. Verify the result
552 EXPECT_EQ(ret, MSERR_INVALID_OPERATION);
553 EXPECT_EQ(hiplayer_->isStreaming_, false);
554 }
555
556 /**
557 * @tc.name : Test Play API
558 * @tc.number : Play_003
559 * @tc.desc : Test Play interface, pipelineStates_ is other states.
560 * @tc.require : issueI5NZAQ
561 */
562 HWTEST_F(HiplayerImplUnitTest, Play_003, TestSize.Level0)
563 {
564 // 1. Set up the test environment
565 hiplayer_->pipelineStates_ = PlayerStates::PLAYER_PREPARING;
566 hiplayer_->isStreaming_ = false;
567 hiplayer_->playRangeStartTime_ = 100;
568 hiplayer_->playRangeEndTime_ = 200;
569
570 // 2. Call the function to be tested
571 int32_t ret = hiplayer_->Play();
572
573 // 3. Verify the result
574 EXPECT_EQ(ret, MSERR_INVALID_OPERATION);
575 EXPECT_EQ(hiplayer_->isStreaming_, false);
576 }
577
578 /**
579 * @tc.name : Test Play API
580 * @tc.number : Play_004
581 * @tc.desc : Test Play interface, playRangeStartTime_ and playRangeEndTime_ is invalid.
582 * @tc.require : issueI5NZAQ
583 */
584 HWTEST_F(HiplayerImplUnitTest, Play_004, TestSize.Level0)
585 {
586 // 1. Set up the test environment
587 hiplayer_->pipelineStates_ = PlayerStates::PLAYER_PLAYBACK_COMPLETE;
588 hiplayer_->isStreaming_ = false;
589 hiplayer_->playRangeStartTime_ = 200;
590 hiplayer_->playRangeEndTime_ = 100;
591
592 // 2. Call the function to be tested
593 int32_t ret = hiplayer_->Play();
594
595 // 3. Verify the result
596 EXPECT_EQ(ret, MSERR_INVALID_OPERATION);
597 EXPECT_EQ(hiplayer_->isStreaming_, false);
598 }
599
600 /**
601 * @tc.name : Test PauseDemuxer API
602 * @tc.number : PauseDemuxer_001
603 * @tc.desc : Test PauseDemuxer interface, return MSERR_OK.
604 * @tc.require : issueI5NZAQ
605 */
606 HWTEST_F(HiplayerImplUnitTest, PauseDemuxer_001, TestSize.Level0)
607 {
608 // 1. Set up the test environment
609 std::string name = "builtin.player.demuxer";
610 std::shared_ptr<DemuxerFilterMock> demuxerMock =
611 std::make_shared<DemuxerFilterMock>(name, FilterType::FILTERTYPE_DEMUXER);
612 hiplayer_->demuxer_ = demuxerMock;
613
614 // 2. Call the function to be tested
615 int32_t ret = hiplayer_->PauseDemuxer();
616
617 // 3. Verify the result
618 EXPECT_EQ(ret, MSERR_OK);
619 }
620
621 /**
622 * @tc.name : Test SeekToCurrentTime API
623 * @tc.number : SeekToCurrentTime_001
624 * @tc.desc : Test SeekToCurrentTime interface, return MSERR_INVALID_VAL.
625 * @tc.require : issueI5NZAQ
626 */
627 HWTEST_F(HiplayerImplUnitTest, SeekToCurrentTime_001, TestSize.Level0)
628 {
629 // 1. Set up the test environment
630 int32_t mSeconds = -100;
631 PlayerSeekMode mode = PlayerSeekMode::SEEK_NEXT_SYNC;
632
633 // 2. Call the function to be tested
634 int32_t ret = hiplayer_->SeekToCurrentTime(mSeconds, mode);
635
636 // 3. Verify the result
637 EXPECT_EQ(ret, MSERR_INVALID_VAL);
638 }
639
640 /**
641 * @tc.name : Test HandleSeek API
642 * @tc.number : HandleSeek_001
643 * @tc.desc : Test HandleSeek interface, pipelineStates_ is PLAYER_STOPPED.
644 * @tc.require : issueI5NZAQ
645 */
646 HWTEST_F(HiplayerImplUnitTest, HandleSeek_001, TestSize.Level0)
647 {
648 // 1. Set up the test environment
649 int64_t seekPos = 100;
650 PlayerSeekMode mode = PlayerSeekMode::SEEK_NEXT_SYNC;
651 hiplayer_->pipelineStates_ = PLAYER_STOPPED;
652
653 // 2. Call the function to be tested
654 Status ret = hiplayer_->HandleSeek(seekPos, mode);
655
656 // 3. Verify the result
657 EXPECT_EQ(ret, Status::ERROR_WRONG_STATE);
658 }
659
660 /**
661 * @tc.name : Test NotifySeek API
662 * @tc.number : NotifySeek_001
663 * @tc.desc : Test NotifySeek interface, Status is ERROR_UNKNOWN.
664 * @tc.require : issueI5NZAQ
665 */
666 HWTEST_F(HiplayerImplUnitTest, NotifySeek_001, TestSize.Level0)
667 {
668 // 1. Set up the test environment
669 Status rtv = Status::ERROR_UNKNOWN;
670 bool flag = true;
671 int64_t seekPos = 100;
672
673 // 2. Call the function to be tested
674 hiplayer_->NotifySeek(rtv, flag, seekPos);
675
676 // 3. Verify the result
677 EXPECT_EQ(hiplayer_->pipelineStates_, PlayerStates::PLAYER_STATE_ERROR);
678 }
679
680 /**
681 * @tc.name : Test Seek API
682 * @tc.number : Seek_001
683 * @tc.desc : Test Seek interface, startTimeWithMode_ == PLAY_RANGE_DEFAULT_VALUE.
684 * @tc.require : issueI5NZAQ
685 */
686 HWTEST_F(HiplayerImplUnitTest, Seek_001, TestSize.Level0)
687 {
688 // 1. Set up the test environment
689 hiplayer_->endTimeWithMode_ = 100;
690 hiplayer_->startTimeWithMode_ = -1;
691 int32_t mSeconds = 90;
692 PlayerSeekMode mode = PlayerSeekMode::SEEK_NEXT_SYNC;
693
694 // 2. Call the function to be tested
695 int32_t ret = hiplayer_->Seek(mSeconds, mode);
696
697 // 3. Verify the result
698 EXPECT_EQ(ret, MSERR_INVALID_VAL);
699 }
700
701 HWTEST_F(HiplayerImplUnitTest, GetCurrentTrack_001, TestSize.Level0)
702 {
703 hiplayer_->demuxer_ = nullptr;
704 hiplayer_->currentAudioTrackId_ = -1;
705 hiplayer_->currentSubtitleTrackId_ = -1;
706 hiplayer_->currentVideoTrackId_ = -1;
707 EXPECT_EQ(hiplayer_->IsSubtitleMime("application/x-subrip"), true);
708 EXPECT_EQ(hiplayer_->IsSubtitleMime("text/vtt"), true);
709
710 int32_t index;
711 EXPECT_EQ(hiplayer_->GetCurrentTrack(OHOS::Media::MediaType::MEDIA_TYPE_AUD, index), MSERR_UNKNOWN);
712 EXPECT_EQ(hiplayer_->GetCurrentTrack(OHOS::Media::MediaType::MEDIA_TYPE_VID, index), MSERR_UNKNOWN);
713 EXPECT_EQ(hiplayer_->GetCurrentTrack(OHOS::Media::MediaType::MEDIA_TYPE_SUBTITLE, index), MSERR_UNKNOWN);
714
715 hiplayer_->currentAudioTrackId_ = 1;
716 hiplayer_->currentSubtitleTrackId_ = 2;
717 hiplayer_->currentVideoTrackId_ = 3;
718 EXPECT_EQ(hiplayer_->GetCurrentTrack(OHOS::Media::MediaType::MEDIA_TYPE_AUD, index), MSERR_OK);
719 EXPECT_EQ(hiplayer_->GetCurrentTrack(OHOS::Media::MediaType::MEDIA_TYPE_VID, index), MSERR_OK);
720 EXPECT_EQ(hiplayer_->GetCurrentTrack(OHOS::Media::MediaType::MEDIA_TYPE_SUBTITLE, index), MSERR_OK);
721 }
722
723 HWTEST_F(HiplayerImplUnitTest, SelectTrack_001, TestSize.Level0)
724 {
725 std::string name = "builtin.player.demuxer";
726 std::shared_ptr<DemuxerFilterMock> demuxerMock =
727 std::make_shared<DemuxerFilterMock>(name, FilterType::FILTERTYPE_DEMUXER);
728
729 std::shared_ptr<Meta> meta1 = std::make_shared<Meta>();
730 meta1->SetData(Tag::MIME_TYPE, "audio/xxx");
731 std::shared_ptr<Meta> meta2 = std::make_shared<Meta>();
732 meta2->SetData(Tag::MIME_TYPE, "video/xxx");
733 std::shared_ptr<Meta> meta3 = std::make_shared<Meta>();
734 meta3->SetData(Tag::MIME_TYPE, "text/vtt");
735 std::shared_ptr<Meta> meta4 = std::make_shared<Meta>();
736
737 demuxerMock->demuxer_->mediaMetaData_.trackMetas.push_back(meta1);
738 demuxerMock->demuxer_->mediaMetaData_.trackMetas.push_back(meta2);
739 demuxerMock->demuxer_->mediaMetaData_.trackMetas.push_back(meta3);
740 demuxerMock->demuxer_->mediaMetaData_.trackMetas.push_back(meta4);
741
742 hiplayer_->demuxer_ = demuxerMock;
743
744 EXPECT_EQ(hiplayer_->SelectTrack(3, SWITCH_SMOOTH), MSERR_INVALID_VAL);
745 hiplayer_->currentAudioTrackId_ = -1;
746 hiplayer_->currentSubtitleTrackId_ = -1;
747 hiplayer_->currentVideoTrackId_ = -1;
748 EXPECT_EQ(hiplayer_->SelectTrack(0, SWITCH_SMOOTH), MSERR_UNKNOWN);
749 EXPECT_EQ(hiplayer_->SelectTrack(1, SWITCH_SMOOTH), MSERR_UNKNOWN);
750 EXPECT_EQ(hiplayer_->SelectTrack(2, SWITCH_SMOOTH), MSERR_UNKNOWN);
751
752 hiplayer_->currentAudioTrackId_ = 101;
753 hiplayer_->currentSubtitleTrackId_ = 102;
754 hiplayer_->currentVideoTrackId_ = 103;
755 EXPECT_EQ(hiplayer_->SelectTrack(0, SWITCH_SMOOTH), MSERR_UNKNOWN);
756 EXPECT_EQ(hiplayer_->SelectTrack(1, SWITCH_SMOOTH), MSERR_UNKNOWN);
757 EXPECT_EQ(hiplayer_->SelectTrack(2, SWITCH_SMOOTH), MSERR_UNKNOWN);
758 }
759
760 HWTEST_F(HiplayerImplUnitTest, DeselectTrack_001, TestSize.Level0)
761 {
762 std::string name = "builtin.player.demuxer";
763 std::shared_ptr<DemuxerFilterMock> demuxerMock =
764 std::make_shared<DemuxerFilterMock>(name, FilterType::FILTERTYPE_DEMUXER);
765
766 std::shared_ptr<Meta> meta1 = std::make_shared<Meta>();
767 meta1->SetData(Tag::MIME_TYPE, "audio/xxx");
768 std::shared_ptr<Meta> meta2 = std::make_shared<Meta>();
769 meta2->SetData(Tag::MIME_TYPE, "video/xxx");
770 std::shared_ptr<Meta> meta3 = std::make_shared<Meta>();
771 meta3->SetData(Tag::MIME_TYPE, "text/vtt");
772 std::shared_ptr<Meta> meta4 = std::make_shared<Meta>();
773
774 demuxerMock->demuxer_->mediaMetaData_.trackMetas.push_back(meta1);
775 demuxerMock->demuxer_->mediaMetaData_.trackMetas.push_back(meta2);
776 demuxerMock->demuxer_->mediaMetaData_.trackMetas.push_back(meta3);
777 demuxerMock->demuxer_->mediaMetaData_.trackMetas.push_back(meta4);
778
779 hiplayer_->demuxer_ = demuxerMock;
780
781 EXPECT_EQ(hiplayer_->DeselectTrack(3), MSERR_INVALID_VAL);
782 hiplayer_->currentAudioTrackId_ = 0;
783 hiplayer_->currentSubtitleTrackId_ = 2;
784 hiplayer_->currentVideoTrackId_ = 1;
785
786 hiplayer_->defaultAudioTrackId_ = 100;
787 hiplayer_->defaultSubtitleTrackId_ = 102;
788 hiplayer_->defaultVideoTrackId_ = 101;
789 EXPECT_EQ(hiplayer_->DeselectTrack(0), MSERR_INVALID_VAL);
790 EXPECT_EQ(hiplayer_->DeselectTrack(1), MSERR_INVALID_VAL);
791 EXPECT_EQ(hiplayer_->DeselectTrack(2), MSERR_OK);
792 EXPECT_EQ(hiplayer_->DeselectTrack(2), MSERR_OK);
793 }
794
795 HWTEST_F(HiplayerImplUnitTest, GetPlaybackInfo_001, TestSize.Level0)
796 {
797 std::string name = "builtin.player.demuxer";
798 std::shared_ptr<DemuxerFilterMock> demuxerMock =
799 std::make_shared<DemuxerFilterMock>(name, FilterType::FILTERTYPE_DEMUXER);
800 hiplayer_->demuxer_ = demuxerMock;
801 hiplayer_->audioSink_ = nullptr;
802
803 hiplayer_->OnEvent({"hiplayer", EventType::EVENT_IS_LIVE_STREAM, false});
804 hiplayer_->OnEvent({"hiplayer", EventType::EVENT_READY, false});
805 hiplayer_->OnEvent({"hiplayer", EventType::BUFFERING_END, 2});
806 hiplayer_->OnEvent({"hiplayer", EventType::BUFFERING_START, 1});
807 hiplayer_->OnEvent({"hiplayer", EventType::EVENT_CACHED_DURATION, 100});
808 hiplayer_->OnEvent({"hiplayer", EventType::EVENT_BUFFER_PROGRESS, 100});
809 hiplayer_->OnEvent({"hiplayer", EventType::EVENT_AUDIO_SERVICE_DIED, 1});
810
811 Format playbackInfo;
812 EXPECT_EQ(hiplayer_->GetPlaybackInfo(playbackInfo), 0);
813 PlaybackRateMode mode;
814 EXPECT_EQ(hiplayer_->GetPlaybackSpeed(mode), MSERR_OK);
815 int32_t effectMode;
816 EXPECT_EQ(hiplayer_->GetAudioEffectMode(effectMode), MSERR_OK);
817 }
818
819 HWTEST_F(HiplayerImplUnitTest, InitAudioDefaultTrackIndex_001, TestSize.Level0)
820 {
821 hiplayer_->demuxer_ = nullptr;
822 EXPECT_EQ(hiplayer_->InitAudioDefaultTrackIndex(), Status::ERROR_UNKNOWN);
823 EXPECT_EQ(hiplayer_->InitVideoDefaultTrackIndex(), Status::ERROR_UNKNOWN);
824 EXPECT_EQ(hiplayer_->InitSubtitleDefaultTrackIndex(), Status::ERROR_UNKNOWN);
825 EXPECT_EQ(hiplayer_->Prepare(), MSERR_OK);
826 }
827
828 HWTEST_F(HiplayerImplUnitTest, ReleaseHiPlayerImplHasSubtitleSink_001, TestSize.Level0)
829 {
830 hiplayer_->subtitleSink_ = std::make_shared<SubtitleSinkFilter>("Test_SubtitleSinkFilter",
831 FilterType::FILTERTYPE_SSINK);
832 hiplayer_->dfxAgent_ = nullptr;
833 uint64_t testInstanceId = 0;
834 hiplayer_->SetInstancdId(testInstanceId);
835 hiplayer_->ReleaseInner();
836 EXPECT_EQ(hiplayer_->subtitleSink_, nullptr);
837 }
838
839 HWTEST_F(HiplayerImplUnitTest, ReleaseHiPlayerImplHasNoDemuxer_001, TestSize.Level0)
840 {
841 hiplayer_->demuxer_ = nullptr;
842 hiplayer_->ReleaseInner();
843 EXPECT_EQ(hiplayer_->demuxer_, nullptr);
844 }
845
846 HWTEST_F(HiplayerImplUnitTest, InitWithNoSyncManager_001, TestSize.Level0)
847 {
848 hiplayer_->syncManager_ = nullptr;
849 EXPECT_EQ(hiplayer_->Init(), Status::OK);
850 }
851
852 HWTEST_F(HiplayerImplUnitTest, SetDefaultAudioRenderInfoWithNullptrMeta_001, TestSize.Level0)
853 {
854 std::shared_ptr<Meta> meta = std::make_shared<Meta>();
855 std::vector<std::shared_ptr<Meta>> trackInfos{meta};
856
857 hiplayer_->syncManager_ = nullptr;
858 EXPECT_EQ(hiplayer_->Init(), Status::OK);
859 }
860
861 HWTEST_F(HiplayerImplUnitTest, ValidSeekTime_001, TestSize.Level0)
862 {
863 hiplayer_->endTimeWithMode_ = 100;
864 hiplayer_->startTimeWithMode_ = 0;
865 int32_t validSeekTime = 10;
866 EXPECT_EQ(hiplayer_->IsInValidSeekTime(validSeekTime), false);
867 }
868
869 HWTEST_F(HiplayerImplUnitTest, InValidSeekTime_001, TestSize.Level0)
870 {
871 hiplayer_->endTimeWithMode_ = 100;
872 hiplayer_->startTimeWithMode_ = 0;
873 int32_t inValidSeekTime = PLAY_RANGE_DEFAULT_VALUE;
874 EXPECT_EQ(hiplayer_->IsInValidSeekTime(inValidSeekTime), true);
875 }
876
877 HWTEST_F(HiplayerImplUnitTest, InValidSeekTime_002, TestSize.Level0)
878 {
879 hiplayer_->endTimeWithMode_ = 100;
880 hiplayer_->startTimeWithMode_ = PLAY_RANGE_DEFAULT_VALUE;
881 int32_t inValidSeekTime = PLAY_RANGE_DEFAULT_VALUE;
882 EXPECT_EQ(hiplayer_->IsInValidSeekTime(inValidSeekTime), false);
883 }
884
885 HWTEST_F(HiplayerImplUnitTest, GetPlayStartTime_001, TestSize.Level0)
886 {
887 int32_t startTime = 100;
888 hiplayer_->playRangeStartTime_ = startTime;
889 EXPECT_EQ(hiplayer_->GetPlayStartTime(), startTime);
890 }
891
892 HWTEST_F(HiplayerImplUnitTest, GetPlayStartTimeWithValidTime_001, TestSize.Level0)
893 {
894 int32_t defaultStartTime = 0;
895 hiplayer_->playRangeStartTime_ = PLAY_RANGE_DEFAULT_VALUE;
896 EXPECT_EQ(hiplayer_->GetPlayStartTime(), defaultStartTime);
897 }
898
899 HWTEST_F(HiplayerImplUnitTest, GetPlayStartTimeWithInValidTime_001, TestSize.Level0)
900 {
901 hiplayer_->startTimeWithMode_ = 0;
902 hiplayer_->endTimeWithMode_ = 100;
903 hiplayer_->playRangeStartTime_ = PLAY_RANGE_DEFAULT_VALUE;
904 EXPECT_EQ(hiplayer_->GetPlayStartTime(), hiplayer_->startTimeWithMode_);
905 }
906
907 HWTEST_F(HiplayerImplUnitTest, GetPlayStartTimeWithInValidTime_002, TestSize.Level0)
908 {
909 int32_t defaultStartTime = 0;
910 hiplayer_->startTimeWithMode_ = PLAY_RANGE_DEFAULT_VALUE;
911 hiplayer_->endTimeWithMode_ = 100;
912 hiplayer_->playRangeStartTime_ = PLAY_RANGE_DEFAULT_VALUE;
913 EXPECT_EQ(hiplayer_->GetPlayStartTime(), defaultStartTime);
914 }
915
916 HWTEST_F(HiplayerImplUnitTest, GetPlayStartTimeWithInValidTime_003, TestSize.Level0)
917 {
918 int32_t defaultStartTime = 0;
919 hiplayer_->startTimeWithMode_ = defaultStartTime;
920 hiplayer_->endTimeWithMode_ = PLAY_RANGE_DEFAULT_VALUE;
921 hiplayer_->playRangeStartTime_ = PLAY_RANGE_DEFAULT_VALUE;
922 EXPECT_EQ(hiplayer_->GetPlayStartTime(), defaultStartTime);
923 }
924
925 HWTEST_F(HiplayerImplUnitTest, SetPlayRangeWithMode_001, TestSize.Level0)
926 {
927 int64_t start = -1;
928 int64_t end = -1;
929 PlayerSeekMode mode = PlayerSeekMode::SEEK_NEXT_SYNC;
930 EXPECT_EQ(hiplayer_->SetPlayRangeWithMode(start, end, mode), MSERR_INVALID_VAL);
931 }
932
933 HWTEST_F(HiplayerImplUnitTest, SetPlayRangeWithMode_002, TestSize.Level0)
934 {
935 int64_t start = 0;
936 int64_t end = 100;
937 PlayerSeekMode mode = PlayerSeekMode::SEEK_NEXT_SYNC;
938 hiplayer_->pipelineStates_ = PlayerStates::PLAYER_INITIALIZED;
939 EXPECT_EQ(hiplayer_->SetPlayRangeWithMode(start, end, mode), MSERR_OK);
940 }
941
942 HWTEST_F(HiplayerImplUnitTest, SetPlayRangeWithMode_003, TestSize.Level0)
943 {
944 int64_t start = 0;
945 int64_t end = 100;
946 PlayerSeekMode mode = PlayerSeekMode::SEEK_NEXT_SYNC;
947 hiplayer_->pipelineStates_ = PlayerStates::PLAYER_STOPPED;
948 EXPECT_EQ(hiplayer_->SetPlayRangeWithMode(start, end, mode), MSERR_INVALID_VAL);
949 }
950
951 HWTEST_F(HiplayerImplUnitTest, SetPlayRangeWithMode_004, TestSize.Level0)
952 {
953 int64_t start = 0;
954 int64_t end = 100;
955 PlayerSeekMode mode = PlayerSeekMode::SEEK_NEXT_SYNC;
956 hiplayer_->pipelineStates_ = PlayerStates::PLAYER_IDLE;
957 EXPECT_EQ(hiplayer_->SetPlayRangeWithMode(start, end, mode), MSERR_INVALID_VAL);
958 }
959
960 HWTEST_F(HiplayerImplUnitTest, SetPlayRangeWithMode_005, TestSize.Level0)
961 {
962 int64_t start = 0;
963 int64_t end = 100;
964 PlayerSeekMode mode = PlayerSeekMode::SEEK_NEXT_SYNC;
965 std::string url = "";
966 hiplayer_->DoSetSource(std::make_shared<MediaSource>(url));
967 hiplayer_->pipelineStates_ = PlayerStates::PLAYER_IDLE;
968 EXPECT_EQ(hiplayer_->SetPlayRangeWithMode(start, end, mode), MSERR_INVALID_VAL);
969 }
970
971 HWTEST_F(HiplayerImplUnitTest, SetRenderFirstFrame_001, TestSize.Level0)
972 {
973 int32_t ret = hiplayer_->SetRenderFirstFrame(true);
974 EXPECT_EQ(ret, MSERR_OK);
975 EXPECT_EQ(hiplayer_->renderFirstFrame_, true);
976 }
977
978 HWTEST_F(HiplayerImplUnitTest, SetRenderFirstFrame_002, TestSize.Level0)
979 {
980 int32_t ret = hiplayer_->SetRenderFirstFrame(false);
981 EXPECT_EQ(ret, MSERR_OK);
982 EXPECT_EQ(hiplayer_->renderFirstFrame_, false);
983 }
984
985 HWTEST_F(HiplayerImplUnitTest, PrepareAsync_001, TestSize.Level0)
986 {
987 int32_t ret = hiplayer_->SetSource(VIDEO_FILE1);
988 EXPECT_EQ(MSERR_OK, ret);
989 hiplayer_->pipelineStates_ = PlayerStates::PLAYER_INITIALIZED;
990 EXPECT_EQ(MSERR_OK, hiplayer_->PrepareAsync());
991 }
992
993 HWTEST_F(HiplayerImplUnitTest, PrepareAsync_002, TestSize.Level0)
994 {
995 int32_t ret = hiplayer_->SetSource(VIDEO_FILE1);
996 EXPECT_EQ(MSERR_OK, ret);
997 hiplayer_->pipelineStates_ = PlayerStates::PLAYER_STOPPED;
998 EXPECT_EQ(MSERR_OK, hiplayer_->PrepareAsync());
999 }
1000
1001 HWTEST_F(HiplayerImplUnitTest, SetAudioEffectMode_001, TestSize.Level0)
1002 {
1003 EXPECT_EQ(MSERR_OK, hiplayer_->SetAudioEffectMode(0));
1004 }
1005
1006 HWTEST_F(HiplayerImplUnitTest, SetAudioEffectMode_002, TestSize.Level0)
1007 {
1008 hiplayer_->audioSink_ = FilterFactory::Instance().CreateFilter<AudioSinkFilter>("player.audiosink",
1009 FilterType::FILTERTYPE_ASINK);
1010 EXPECT_EQ(MSERR_UNKNOWN, hiplayer_->SetAudioEffectMode(1));
1011 }
1012
1013 HWTEST_F(HiplayerImplUnitTest, GetAudioEffectMode_001, TestSize.Level0)
1014 {
1015 hiplayer_->audioSink_ = FilterFactory::Instance().CreateFilter<AudioSinkFilter>("player.audiosink",
1016 FilterType::FILTERTYPE_ASINK);
1017 int32_t effect = 1;
1018 EXPECT_EQ(MSERR_UNKNOWN, hiplayer_->GetAudioEffectMode(effect));
1019 }
1020
1021 HWTEST_F(HiplayerImplUnitTest, SetPlaybackSpeed_001, TestSize.Level0)
1022 {
1023 hiplayer_->subtitleSink_ = FilterFactory::Instance().CreateFilter<SubtitleSinkFilter>("player.subtitlesink",
1024 FilterType::FILTERTYPE_SSINK);
1025 hiplayer_->syncManager_ = nullptr;
1026 EXPECT_EQ(MSERR_OK, hiplayer_->SetPlaybackSpeed(PlaybackRateMode::SPEED_FORWARD_2_00_X));
1027 }
1028
1029 HWTEST_F(HiplayerImplUnitTest, SetPlaybackRate_001, TestSize.Level0)
1030 {
1031 float rate = 2.0f;
1032 hiplayer_->subtitleSink_ = FilterFactory::Instance().CreateFilter<SubtitleSinkFilter>("player.subtitlesink",
1033 FilterType::FILTERTYPE_SSINK);
1034 hiplayer_->syncManager_ = nullptr;
1035 EXPECT_EQ(MSERR_OK, hiplayer_->SetPlaybackRate(rate));
1036 }
1037
1038 HWTEST_F(HiplayerImplUnitTest, SetPlaybackSpeed_002, TestSize.Level0)
1039 {
1040 PlaybackRateMode mode = PlaybackRateMode::SPEED_FORWARD_2_00_X;
1041 hiplayer_->audioSink_ = FilterFactory::Instance().CreateFilter<AudioSinkFilter>("player.audiosink",
1042 FilterType::FILTERTYPE_ASINK);
1043 hiplayer_->subtitleSink_ = nullptr;
1044 EXPECT_EQ(MSERR_UNKNOWN, hiplayer_->SetPlaybackSpeed(mode));
1045 }
1046
1047 HWTEST_F(HiplayerImplUnitTest, SetPlaybackRate_002, TestSize.Level0)
1048 {
1049 float rate = 2.0f;
1050 hiplayer_->audioSink_ = FilterFactory::Instance().CreateFilter<AudioSinkFilter>("player.audiosink",
1051 FilterType::FILTERTYPE_ASINK);
1052 hiplayer_->subtitleSink_ = nullptr;
1053 EXPECT_EQ(MSERR_UNKNOWN, hiplayer_->SetPlaybackRate(rate));
1054 }
1055
1056 HWTEST_F(HiplayerImplUnitTest, IsNeedAudioSinkChangeTrack_001, TestSize.Level0)
1057 {
1058 std::shared_ptr<Meta> meta = std::make_shared<Meta>();
1059 std::vector<std::shared_ptr<Meta>> trackInfos{meta};
1060 int32_t trackId = 0;
1061 hiplayer_->currentAudioTrackId_ = 0;
1062 EXPECT_EQ(false, hiplayer_->IsNeedAudioSinkChangeTrack(trackInfos, trackId));
1063 }
1064
1065 HWTEST_F(HiplayerImplUnitTest, InnerSelectTrack_001, TestSize.Level0)
1066 {
1067 std::string mime = "video/mp4";
1068 int32_t trackId = 1;
1069 PlayerSwitchMode mode = PlayerSwitchMode::SWITCH_SMOOTH;
1070 hiplayer_->demuxer_ = FilterFactory::Instance().CreateFilter<DemuxerFilter>("builtin.player.demuxer",
1071 FilterType::FILTERTYPE_DEMUXER);
1072 EXPECT_EQ(MSERR_UNKNOWN, hiplayer_->InnerSelectTrack(mime, trackId, mode));
1073 }
1074
1075 HWTEST_F(HiplayerImplUnitTest, GetSarVideoWidth_001, TestSize.Level0)
1076 {
1077 double videoSar = 0;
1078 double width = 1;
1079 std::shared_ptr<Meta> trackInfo = std::make_shared<Meta>();
1080
1081 trackInfo->SetData(Tag::VIDEO_SAR, videoSar);
1082 trackInfo->SetData(Tag::VIDEO_WIDTH, width);
1083 EXPECT_EQ(0, hiplayer_->GetSarVideoWidth(trackInfo));
1084 }
1085
1086 HWTEST_F(HiplayerImplUnitTest, GetSarVideoHeight_001, TestSize.Level0)
1087 {
1088 std::shared_ptr<Meta> trackInfo = std::make_shared<Meta>();
1089 double videoSar = 2;
1090 int32_t height = 2;
1091 trackInfo->SetData(Tag::VIDEO_SAR, videoSar);
1092 trackInfo->SetData(Tag::VIDEO_HEIGHT, height);
1093 EXPECT_EQ(1, hiplayer_->GetSarVideoHeight(trackInfo));
1094 }
1095
1096 HWTEST_F(HiplayerImplUnitTest, SetMaxAmplitudeCbStatus_001, TestSize.Level0)
1097 {
1098 bool status = true;
1099 hiplayer_->audioSink_ = FilterFactory::Instance().CreateFilter<AudioSinkFilter>("player.audiosink",
1100 FilterType::FILTERTYPE_ASINK);
1101 EXPECT_EQ(MSERR_OK, hiplayer_->SetMaxAmplitudeCbStatus(status));
1102 EXPECT_EQ(true, hiplayer_->maxAmplitudeCbStatus_);
1103 }
1104
1105 HWTEST_F(HiplayerImplUnitTest, TestHiplayerImplDestructor, TestSize.Level0)
1106 {
1107 std::unique_ptr<HiPlayerImpl> player = std::make_unique<HiPlayerImpl>(0, 0, 0, 0);
1108 EXPECT_NE(player, nullptr);
1109 {
1110 auto destructedPlayer = std::move(player);
1111 EXPECT_NE(destructedPlayer, nullptr);
1112 }
1113 EXPECT_EQ(player, nullptr);
1114 }
1115
1116 HWTEST_F(HiplayerImplUnitTest, TestHiplayerImplLag_001, TestSize.Level0)
1117 {
1118 std::unique_ptr<HiPlayerImpl> player = std::make_unique<HiPlayerImpl>(0, 0, 0, 0);
1119 ASSERT_NE(player, nullptr);
1120 ASSERT_NE(player->dfxAgent_, nullptr);
1121 EXPECT_EQ(player->dfxAgent_->hasReported_, false);
1122 player->Init();
1123 ASSERT_NE(player->playerEventReceiver_, nullptr);
1124 player->playerEventReceiver_->OnDfxEvent(
1125 {"HiPlayerImplUnitTest", DfxEventType::DFX_INFO_PLAYER_AUDIO_LAG, 1000});
1126 usleep(100000); // sleep 100 ms to wait for hasReported_ change
1127 EXPECT_EQ(player->dfxAgent_->hasReported_, true);
1128 }
1129
1130 HWTEST_F(HiplayerImplUnitTest, TestHiplayerImplLag_002, TestSize.Level0)
1131 {
1132 std::unique_ptr<HiPlayerImpl> player = std::make_unique<HiPlayerImpl>(0, 0, 0, 0);
1133 ASSERT_NE(player, nullptr);
1134 ASSERT_NE(player->dfxAgent_, nullptr);
1135 EXPECT_EQ(player->dfxAgent_->hasReported_, false);
1136 player->Init();
1137 ASSERT_NE(player->playerEventReceiver_, nullptr);
1138 player->playerEventReceiver_->OnDfxEvent(
1139 {"HiPlayerImplUnitTest", DfxEventType::DFX_INFO_PLAYER_VIDEO_LAG, 1000});
1140 usleep(100000); // sleep 100 ms to wait for hasReported_ change
1141 EXPECT_EQ(player->dfxAgent_->hasReported_, true);
1142 }
1143
1144 HWTEST_F(HiplayerImplUnitTest, TestHiplayerImplLag_003, TestSize.Level0)
1145 {
1146 std::unique_ptr<HiPlayerImpl> player = std::make_unique<HiPlayerImpl>(0, 0, 0, 0);
1147 ASSERT_NE(player, nullptr);
1148 ASSERT_NE(player->dfxAgent_, nullptr);
1149 EXPECT_EQ(player->dfxAgent_->hasReported_, false);
1150 player->Init();
1151 ASSERT_NE(player->playerEventReceiver_, nullptr);
1152 player->playerEventReceiver_->OnDfxEvent(
1153 {"HiPlayerImplUnitTest", DfxEventType::DFX_INFO_PLAYER_STREAM_LAG, 1000});
1154 usleep(100000); // sleep 100 ms to wait for hasReported_ change
1155 EXPECT_EQ(player->dfxAgent_->hasReported_, true);
1156 }
1157
1158 /**
1159 * @tc.name : Test IsSeekContinuousSupported API
1160 * @tc.number : IsSeekContinuousSupported_001
1161 * @tc.desc : Test IsSeekContinuousSupported interface.
1162 * @tc.require :
1163 */
1164 HWTEST_F(HiplayerImplUnitTest, TestIsSeekContinuousSupported_001, TestSize.Level0)
1165 {
1166 std::unique_ptr<HiPlayerImpl> player = std::make_unique<HiPlayerImpl>(0, 0, 0, 0);
1167 ASSERT_NE(player, nullptr);
1168 bool isSupported = false;
1169 ASSERT_NE(player->IsSeekContinuousSupported(isSupported), 0);
1170 player->demuxer_ = FilterFactory::Instance().CreateFilter<DemuxerFilter>("builtin.player.demuxer",
1171 FilterType::FILTERTYPE_DEMUXER);
1172 player->videoDecoder_ = FilterFactory::Instance().CreateFilter<DecoderSurfaceFilter>("player.videodecoder",
1173 FilterType::FILTERTYPE_VDEC);
1174 EXPECT_EQ(player->IsSeekContinuousSupported(isSupported), 0);
1175 }
1176
1177 HWTEST_F(HiplayerImplUnitTest, TestSetSuperResolution_001, TestSize.Level0)
1178 {
1179 auto ret = hiplayer_->SetSuperResolution(true);
1180 EXPECT_EQ(ret, MSERR_SUPER_RESOLUTION_NOT_ENABLED);
1181 hiplayer_->videoPostProcessorType_ = VideoPostProcessorType::SUPER_RESOLUTION;
1182 ret = hiplayer_->SetSuperResolution(true);
1183 EXPECT_EQ(ret, MSERR_OK);
1184 }
1185
1186 HWTEST_F(HiplayerImplUnitTest, TestSetSuperResolution_002, TestSize.Level0)
1187 {
1188 std::unique_ptr<HiPlayerImpl> player = std::make_unique<HiPlayerImpl>(0, 0, 0, 0);
1189 ASSERT_NE(player, nullptr);
1190 player->videoDecoder_ = FilterFactory::Instance().CreateFilter<DecoderSurfaceFilter>("player.videodecoder",
1191 FilterType::FILTERTYPE_VDEC);
1192
1193 player->videoPostProcessorType_ = VideoPostProcessorType::SUPER_RESOLUTION;
1194 player->videoDecoder_->isPostProcessorSupported_ = false;
1195 auto ret = player->SetSuperResolution(true);
1196 EXPECT_EQ(ret, MSERR_SUPER_RESOLUTION_UNSUPPORTED);
1197
1198 player->videoDecoder_->isPostProcessorSupported_ = true;
1199 ret = player->SetSuperResolution(true);
1200 EXPECT_EQ(ret, TransStatus(Status::OK));
1201 }
1202
1203 HWTEST_F(HiplayerImplUnitTest, SetCameraPostprocessing_001, TestSize.Level0)
1204 {
1205 auto ret = hiplayer_->SetCameraPostprocessing(true);
1206 EXPECT_EQ(ret, MSERR_OK);
1207 ret = hiplayer_->SetCameraPostprocessing(false);
1208 EXPECT_EQ(ret, MSERR_OK);
1209 }
1210
1211 HWTEST_F(HiplayerImplUnitTest, TestSetVideoWindowSize_001, TestSize.Level0)
1212 {
1213 int32_t width = 0;
1214 int32_t height = 0;
1215 auto ret = hiplayer_->SetVideoWindowSize(width, height);
1216 EXPECT_EQ(ret, MSERR_SUPER_RESOLUTION_NOT_ENABLED);
1217
1218 hiplayer_->videoPostProcessorType_ = VideoPostProcessorType::SUPER_RESOLUTION;
1219 ret = hiplayer_->SetVideoWindowSize(width, height);
1220 EXPECT_EQ(ret, MSERR_INVALID_VAL);
1221
1222 width = 320;
1223 height = 320;
1224 ret = hiplayer_->SetVideoWindowSize(width, height);
1225 EXPECT_EQ(ret, MSERR_OK);
1226
1227 width = 1920;
1228 height = 1080;
1229 ret = hiplayer_->SetVideoWindowSize(width, height);
1230 EXPECT_EQ(ret, MSERR_OK);
1231
1232 width = 1080;
1233 height = 720;
1234 ret = hiplayer_->SetVideoWindowSize(width, height);
1235 EXPECT_EQ(ret, MSERR_OK);
1236
1237 width = 1921;
1238 height = 1080;
1239 ret = hiplayer_->SetVideoWindowSize(width, height);
1240 EXPECT_EQ(ret, MSERR_INVALID_VAL);
1241
1242 width = 1920;
1243 height = 1081;
1244 ret = hiplayer_->SetVideoWindowSize(width, height);
1245 EXPECT_EQ(ret, MSERR_INVALID_VAL);
1246 }
1247
1248 HWTEST_F(HiplayerImplUnitTest, TestSetPlaybackStrategy_001, TestSize.Level0)
1249 {
1250 AVPlayStrategy strategy;
1251 strategy.enableSuperResolution = false;
1252 strategy.keepDecodingOnMute = false;
1253 auto ret = hiplayer_->SetPlaybackStrategy(strategy);
1254 EXPECT_EQ(ret, MSERR_OK);
1255 EXPECT_EQ(hiplayer_->videoPostProcessorType_, VideoPostProcessorType::NONE);
1256 EXPECT_EQ(hiplayer_->isPostProcessorOn_, false);
1257 EXPECT_EQ(hiplayer_->keepDecodingOnMute_, false);
1258
1259 strategy.enableSuperResolution = true;
1260 strategy.keepDecodingOnMute = true;
1261 ret = hiplayer_->SetPlaybackStrategy(strategy);
1262 EXPECT_EQ(ret, MSERR_OK);
1263 EXPECT_EQ(hiplayer_->videoPostProcessorType_, VideoPostProcessorType::SUPER_RESOLUTION);
1264 EXPECT_EQ(hiplayer_->isPostProcessorOn_, true);
1265 }
1266 /**
1267 * @tc.name : TestHandleMemoryUsageEvent_001
1268 * @tc.number: TestHandleMemoryUsageEvent_001
1269 * @tc.desc : Test the scenario where the caller is not DEMUXER_PLUGIN
1270 */
1271 HWTEST_F(HiplayerImplUnitTest, TestHandleMemoryUsageEvent_001, TestSize.Level0)
1272 {
1273 DfxEvent event;
1274 event.callerName = "TEST";
1275 event.param = static_cast<uint32_t>(1024);
1276 hiplayer_->HandleMemoryUsageEvent(event);
1277 std::cout<<hiplayer_->memoryUsageInfo_[TOTAL_MEMORY_SIZE]<<std::endl;
1278 EXPECT_EQ(hiplayer_->memoryUsageInfo_[TOTAL_MEMORY_SIZE], 1); // parm
1279 }
1280
1281 /**
1282 * @tc.name : TestHandleMemoryUsageEvent_002
1283 * @tc.number: TestHandleMemoryUsageEvent_002
1284 * @tc.desc : Test the scenario where the caller is not DEMUXER_PLUGIN, report coverage
1285 */
1286 HWTEST_F(HiplayerImplUnitTest, TestHandleMemoryUsageEvent_002, TestSize.Level0)
1287 {
1288 DfxEvent event;
1289 event.callerName = "TEST";
1290 event.param = static_cast<uint32_t>(1024);
1291 hiplayer_->HandleMemoryUsageEvent(event);
1292 event.param = static_cast<uint32_t>(2048);
1293 hiplayer_->HandleMemoryUsageEvent(event);
1294 EXPECT_EQ(hiplayer_->memoryUsageInfo_[TOTAL_MEMORY_SIZE], 2); // parm
1295 }
1296
1297 /**
1298 * @tc.name : TestHandleMemoryUsageEvent_003
1299 * @tc.number: TestHandleMemoryUsageEvent_003
1300 * @tc.desc : Test the scenario where the caller is not DEMUXER_PLUGIN, report coverage
1301 */
1302 HWTEST_F(HiplayerImplUnitTest, TestHandleMemoryUsageEvent_003, TestSize.Level0)
1303 {
1304 DfxEvent event;
1305 event.callerName = "TEST";
1306 event.param = static_cast<uint32_t>(2048);
1307 hiplayer_->HandleMemoryUsageEvent(event);
1308 EXPECT_EQ(hiplayer_->memoryUsageInfo_[TOTAL_MEMORY_SIZE], 2); // parm
1309 event.param = static_cast<uint32_t>(1024);
1310 hiplayer_->HandleMemoryUsageEvent(event);
1311 EXPECT_EQ(hiplayer_->memoryUsageInfo_[TOTAL_MEMORY_SIZE], 1); // parm
1312 }
1313
1314 /**
1315 * @tc.name : TestHandleMemoryUsageEvent_004
1316 * @tc.number: TestHandleMemoryUsageEvent_004
1317 * @tc.desc : Test the scenario where the caller is DEMUXER_PLUGIN
1318 */
1319 HWTEST_F(HiplayerImplUnitTest, TestHandleMemoryUsageEvent_004, TestSize.Level0)
1320 {
1321 DfxEvent event;
1322 event.callerName = "DEMUXER_PLUGIN";
1323 event.param = std::unordered_map<uint32_t, uint32_t>{{1, 1024}, {2, 1024}};
1324
1325 hiplayer_->HandleMemoryUsageEvent(event);
1326 EXPECT_EQ(hiplayer_->memoryUsageInfo_[TOTAL_MEMORY_SIZE], 2); // parm
1327 }
1328
1329 /**
1330 * @tc.name : TestHandleMemoryUsageEvent_005
1331 * @tc.number: TestHandleMemoryUsageEvent_005
1332 * @tc.desc : Test the scenario where the caller is DEMUXER_PLUGIN, Exceeding the limit
1333 */
1334 HWTEST_F(HiplayerImplUnitTest, TestHandleMemoryUsageEvent_005, TestSize.Level0)
1335 {
1336 uint32_t reportMemory = 50 * 1024 * 1024;
1337 DfxEvent event;
1338 event.callerName = "DEMUXER_PLUGIN";
1339 event.param = std::unordered_map<uint32_t, uint32_t>{{1, reportMemory}, {2, reportMemory}};
1340
1341 hiplayer_->HandleMemoryUsageEvent(event);
1342 EXPECT_EQ(hiplayer_->memoryUsageInfo_["DEMUXER_PLUGIN"], 102400); // 102400 means 100MB
1343 EXPECT_EQ(hiplayer_->memoryUsageInfo_[TOTAL_MEMORY_SIZE], 51200); // 51200 meads 50MB
1344 }
1345
1346 /**
1347 * @tc.name : TestHandleMemoryUsageEvent_006
1348 * @tc.number: TestHandleMemoryUsageEvent_006
1349 * @tc.desc : Test the scenario where the caller is DEMUXER_PLUGIN, Exceeding the limit
1350 */
1351 HWTEST_F(HiplayerImplUnitTest, TestHandleMemoryUsageEvent_006, TestSize.Level0)
1352 {
1353 uint32_t reportMemory = 50 * 1024 * 1024;
1354 DfxEvent event;
1355 event.callerName = "DEMUXER_PLUGIN";
1356 event.param = std::unordered_map<uint32_t, uint32_t>{{1, reportMemory}, {2, reportMemory}};
1357
1358 hiplayer_->HandleMemoryUsageEvent(event);
1359 EXPECT_EQ(hiplayer_->memoryUsageInfo_["DEMUXER_PLUGIN"], 102400); // 102400 means 100MB
1360 EXPECT_EQ(hiplayer_->memoryUsageInfo_[TOTAL_MEMORY_SIZE], 51200); // 51200 meads 50MB
1361
1362 event.param = std::unordered_map<uint32_t, uint32_t>{{1, 1024}, {2, 1024}};
1363 hiplayer_->HandleMemoryUsageEvent(event);
1364 EXPECT_EQ(hiplayer_->memoryUsageInfo_["DEMUXER_PLUGIN"], 2); // parm
1365 EXPECT_EQ(hiplayer_->memoryUsageInfo_[TOTAL_MEMORY_SIZE], 2); // parm
1366 }
1367
1368 /**
1369 * @tc.name : Test flv smart play
1370 * @tc.number : IsLivingMaxDelayTimeValid_001
1371 * @tc.desc : Test flv live Max Delay Time isValid
1372 * @tc.require :
1373 */
1374 HWTEST_F(HiplayerImplUnitTest, IsLivingMaxDelayTimeValid_001, TestSize.Level0)
1375 {
1376 hiplayer_->maxLivingDelayTime_ = -1;
1377 EXPECT_TRUE(hiplayer_->IsLivingMaxDelayTimeValid());
1378 hiplayer_->maxLivingDelayTime_ = 0;
1379 EXPECT_FALSE(hiplayer_->IsLivingMaxDelayTimeValid());
1380 hiplayer_->maxLivingDelayTime_ = AVPlayStrategyConstant::BUFFER_DURATION_FOR_PLAYING_SECONDS;
1381 hiplayer_->bufferDurationForPlaying_ = 0;
1382 EXPECT_TRUE(hiplayer_->IsLivingMaxDelayTimeValid());
1383 hiplayer_->bufferDurationForPlaying_ = AVPlayStrategyConstant::START_QUICK_PLAY_THRESHOLD_SECONDS;
1384 EXPECT_FALSE(hiplayer_->IsLivingMaxDelayTimeValid());
1385 }
1386
1387 /**
1388 * @tc.name : Test flv smart play
1389 * @tc.number : IsNeedChangePlaySpeed_001
1390 * @tc.desc : Test resume normal speed play
1391 * @tc.require :
1392 */
1393 HWTEST_F(HiplayerImplUnitTest, IsNeedChangePlaySpeed_001, TestSize.Level0)
1394 {
1395 hiplayer_->demuxer_ = FilterFactory::Instance().CreateFilter<DemuxerFilter>("builtin.player.demuxer",
1396 FilterType::FILTERTYPE_DEMUXER);
1397 PlaybackRateMode mode = PlaybackRateMode::SPEED_FORWARD_1_20_X;
1398 bool isXSpeedPlay = true;
1399 hiplayer_->isFlvLive_ = true;
1400 hiplayer_->bufferDurationForPlaying_ = AVPlayStrategyConstant::BUFFER_DURATION_FOR_PLAYING_SECONDS;
1401 EXPECT_TRUE(hiplayer_->IsNeedChangePlaySpeed(mode, isXSpeedPlay));
1402 EXPECT_EQ(mode, PlaybackRateMode::SPEED_FORWARD_1_00_X);
1403 EXPECT_EQ(isXSpeedPlay, false);
1404 }
1405
1406 /**
1407 * @tc.name : Test flv smart play
1408 * @tc.number : IsNeedChangePlaySpeed_002
1409 * @tc.desc : Test 1.2X speed play
1410 * @tc.require :
1411 */
1412 HWTEST_F(HiplayerImplUnitTest, IsNeedChangePlaySpeed_002, TestSize.Level0)
1413 {
1414 hiplayer_->demuxer_ = FilterFactory::Instance().CreateFilter<DemuxerFilter>("builtin.player.demuxer",
1415 FilterType::FILTERTYPE_DEMUXER);
1416 PlaybackRateMode mode = PlaybackRateMode::SPEED_FORWARD_1_00_X;
1417 bool isXSpeedPlay = false;
1418 hiplayer_->isFlvLive_ = true;
1419 hiplayer_->maxLivingDelayTime_ = -1;
1420 EXPECT_TRUE(hiplayer_->IsNeedChangePlaySpeed(mode, isXSpeedPlay));
1421 EXPECT_EQ(mode, PlaybackRateMode::SPEED_FORWARD_1_20_X);
1422 EXPECT_EQ(isXSpeedPlay, true);
1423 }
1424
1425 /**
1426 * @tc.name : Test flv smart play
1427 * @tc.number : IsPauseForTooLong_001
1428 * @tc.desc : Test is pause for too long time
1429 * @tc.require :
1430 */
1431 HWTEST_F(HiplayerImplUnitTest, IsPauseForTooLong_001, TestSize.Level0)
1432 {
1433 hiplayer_->isFlvLive_ = false;
1434 EXPECT_FALSE(hiplayer_->IsFlvLive());
1435 int64_t pauseTime = 1;
1436 hiplayer_->maxLivingDelayTime_ = -1;
1437 EXPECT_TRUE(hiplayer_->IsPauseForTooLong(pauseTime));
1438
1439 hiplayer_->maxLivingDelayTime_ = AVPlayStrategyConstant::START_QUICK_PLAY_THRESHOLD_SECONDS;
1440 EXPECT_FALSE(hiplayer_->IsPauseForTooLong(pauseTime));
1441 }
1442
1443 /**
1444 * @tc.name : Test flv smart play
1445 * @tc.number : SetFlvLiveParams_001
1446 * @tc.desc : Test set flv live params value
1447 * @tc.require :
1448 */
1449 HWTEST_F(HiplayerImplUnitTest, SetFlvLiveParams_001, TestSize.Level0)
1450 {
1451 AVPlayStrategy playbackStrategy;
1452 playbackStrategy.preferredBufferDurationForPlaying = -1;
1453 hiplayer_->isSetBufferDurationForPlaying_ = true;
1454 hiplayer_->SetFlvLiveParams(playbackStrategy);
1455 EXPECT_FALSE(hiplayer_->isSetBufferDurationForPlaying_);
1456 EXPECT_EQ(hiplayer_->bufferDurationForPlaying_, 0);
1457 EXPECT_EQ(hiplayer_->maxLivingDelayTime_, -1);
1458
1459 playbackStrategy.preferredBufferDurationForPlaying = AVPlayStrategyConstant::BUFFER_DURATION_FOR_PLAYING_SECONDS;
1460 playbackStrategy.thresholdForAutoQuickPlay = AVPlayStrategyConstant::START_QUICK_PLAY_THRESHOLD_SECONDS;
1461 hiplayer_->SetFlvLiveParams(playbackStrategy);
1462 EXPECT_TRUE(hiplayer_->isSetBufferDurationForPlaying_);
1463 EXPECT_EQ(hiplayer_->bufferDurationForPlaying_, AVPlayStrategyConstant::BUFFER_DURATION_FOR_PLAYING_SECONDS);
1464 EXPECT_EQ(hiplayer_->maxLivingDelayTime_, AVPlayStrategyConstant::START_QUICK_PLAY_THRESHOLD_SECONDS);
1465 }
1466
1467 /**
1468 * @tc.name : Test flv smart play
1469 * @tc.number : UpdateFlvLiveParams_001
1470 * @tc.desc : Test update flv live params value
1471 * @tc.require :
1472 */
1473 HWTEST_F(HiplayerImplUnitTest, UpdateFlvLiveParams_001, TestSize.Level0)
1474 {
1475 hiplayer_->UpdateFlvLiveParams();
1476 EXPECT_EQ(hiplayer_->maxLivingDelayTime_, AVPlayStrategyConstant::START_QUICK_PLAY_THRESHOLD_SECONDS);
1477 EXPECT_EQ(hiplayer_->bufferDurationForPlaying_, AVPlayStrategyConstant::BUFFER_DURATION_FOR_PLAYING_SECONDS);
1478 }
1479
1480 /**
1481 * @tc.name : Test set audio haptic sync id for audio renderer haptic sync
1482 * @tc.number : SetAudioHapticsSyncId_001
1483 * @tc.desc : Test set audio haptic sync id
1484 * @tc.require :
1485 */
1486 HWTEST_F(HiplayerImplUnitTest, SetAudioHapticsSyncId_001, TestSize.Level0)
1487 {
1488 EXPECT_EQ(hiplayer_->audioHapticsSyncId_, 0); // Expect default value
1489
1490 Format format0;
1491 format0.PutIntValue(PlayerKeys::CONTENT_TYPE, AudioStandard::CONTENT_TYPE_UNKNOWN);
1492 format0.PutIntValue(PlayerKeys::STREAM_USAGE, AudioStandard::STREAM_USAGE_UNKNOWN);
1493 format0.PutIntValue(PlayerKeys::PLAYER_AUDIO_HAPTICS_SYNC_ID, 1); // Call with content type and stream usage
1494 hiplayer_->SetParameter(format0);
1495 EXPECT_EQ(hiplayer_->audioHapticsSyncId_, 1); // Expect success
1496
1497 Format format1;
1498 format1.PutIntValue(PlayerKeys::PLAYER_AUDIO_HAPTICS_SYNC_ID, 2); // call without
1499 hiplayer_->SetParameter(format1);
1500 EXPECT_EQ(hiplayer_->audioHapticsSyncId_, 2); // Expect success
1501
1502 Format format2;
1503 format2.PutIntValue(PlayerKeys::CONTENT_TYPE, AudioStandard::CONTENT_TYPE_UNKNOWN);
1504 format2.PutIntValue(PlayerKeys::STREAM_USAGE, AudioStandard::STREAM_USAGE_UNKNOWN);
1505 format2.PutIntValue(PlayerKeys::PLAYER_AUDIO_HAPTICS_SYNC_ID, 0); // Call with default value
1506 hiplayer_->SetParameter(format2);
1507 EXPECT_EQ(hiplayer_->audioHapticsSyncId_, 0); // Expect success
1508 }
1509 } // namespace Media
1510 } // namespace OHOS