1 /*
2 * Copyright (c) 2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "media_errors.h"
17 #include "hiplayer_impl_unittest.h"
18 #include "pipeline/pipeline.h"
19 #include "player.h"
20 #include "audio_device_descriptor.h"
21 #include "audio_capture_filter.h"
22
23 namespace OHOS {
24 namespace Media {
25 using namespace std;
26 using namespace testing;
27 using namespace testing::ext;
28
SetUpTestCase(void)29 void PlayHiplayerImplUnitTest::SetUpTestCase(void)
30 {
31 }
32
TearDownTestCase(void)33 void PlayHiplayerImplUnitTest::TearDownTestCase(void)
34 {
35 }
36
SetUp(void)37 void PlayHiplayerImplUnitTest::SetUp(void)
38 {
39 hiplayer_ = std::make_shared<HiPlayerImpl>(0, 0, 0, 0);
40 }
41
TearDown(void)42 void PlayHiplayerImplUnitTest::TearDown(void)
43 {
44 if (hiplayer_->demuxer_ != nullptr) {
45 if (hiplayer_->demuxer_->demuxer_ != nullptr) {
46 hiplayer_->demuxer_->demuxer_ = nullptr;
47 }
48 if (hiplayer_->demuxer_->interruptMonitor_ != nullptr) {
49 hiplayer_->demuxer_->interruptMonitor_ = nullptr;
50 }
51 hiplayer_->demuxer_ = nullptr;
52 }
53 hiplayer_ = nullptr;
54 }
55
56 // @tc.name Test SetDefaultAudioRenderInfo API
57 // @tc.number PHIUT_SetDefaultAudioRenderInfo_001
58 // @tc.desc Test SetDefaultAudioRenderInfo interface, 1.
59 HWTEST_F(PlayHiplayerImplUnitTest, PHIUT_SetDefaultAudioRenderInfo_001, TestSize.Level0)
60 {
61 ASSERT_NE(hiplayer_, nullptr);
62 std::vector<std::shared_ptr<Meta>> trackInfos;
63 std::shared_ptr<Meta> testptr = nullptr;
64 trackInfos.push_back(testptr);
65 hiplayer_->SetDefaultAudioRenderInfo(trackInfos);
66 EXPECT_EQ(hiplayer_->isNetWorkPlay_, false);
67 }
68
69 // @tc.name Test SetSource API
70 // @tc.number PHIUT_SetSource_001
71 // @tc.desc Test SetSource interface, 2.
72 HWTEST_F(PlayHiplayerImplUnitTest, PHIUT_SetSource_001, TestSize.Level0)
73 {
74 ASSERT_NE(hiplayer_, nullptr);
75 std::shared_ptr<IMediaDataSource> dataSrc;
76 int32_t ret = hiplayer_->SetSource(dataSrc);
77 EXPECT_EQ(ret, 0);
78 }
79
80 // @tc.name Test PrepareAsync API
81 // @tc.number PHIUT_PrepareAsync_001
82 // @tc.desc Test PrepareAsync interface, 1.
83 HWTEST_F(PlayHiplayerImplUnitTest, PHIUT_PrepareAsync_001, TestSize.Level0)
84 {
85 ASSERT_NE(hiplayer_, nullptr);
86 hiplayer_->pipelineStates_ = PlayerStates::PLAYER_STATE_ERROR;
87 int32_t ret = hiplayer_->PrepareAsync();
88 EXPECT_EQ(ret, 331350054);
89 }
90
91 // @tc.name Test UpdateMediaFirstPts API
92 // @tc.number PHIUT_UpdateMediaFirstPts_001
93 // @tc.desc Test UpdateMediaFirstPts interface, 2.
94 HWTEST_F(PlayHiplayerImplUnitTest, PHIUT_UpdateMediaFirstPts_001, TestSize.Level0)
95 {
96 ASSERT_NE(hiplayer_, nullptr);
97 std::string name = "testname";
98 FilterType type = FilterType::VIDEO_CAPTURE;
99 hiplayer_->demuxer_ = std::make_shared<DemuxerFilter>(name, type);
100 std::shared_ptr<Meta> testptr = nullptr;
101 hiplayer_->demuxer_->demuxer_ = std::make_shared<MediaDemuxer>();
102 hiplayer_->demuxer_->demuxer_->mediaMetaData_.trackMetas.push_back(testptr);
103 hiplayer_->UpdateMediaFirstPts();
104 EXPECT_EQ(hiplayer_->demuxer_->GetStreamMetaInfo().empty(), false);
105 }
106
107 // @tc.name Test SelectBitRate API
108 // @tc.number PHIUT_SelectBitRate_001
109 // @tc.desc Test SelectBitRate interface, 1.
110 HWTEST_F(PlayHiplayerImplUnitTest, PHIUT_SelectBitRate_001, TestSize.Level0)
111 {
112 ASSERT_NE(hiplayer_, nullptr);
113 uint32_t bitRate = 1212;
114 bool isAutoSelect = false;
115 int32_t ret = hiplayer_->SelectBitRate(bitRate, isAutoSelect);
116 EXPECT_NE(ret, 0);
117 }
118
119 // @tc.name Test DoInitializeForHttp API
120 // @tc.number PHIUT_DoInitializeForHttp_001
121 // @tc.desc Test DoInitializeForHttp interface, 1.
122 HWTEST_F(PlayHiplayerImplUnitTest, PHIUT_DoInitializeForHttp_001, TestSize.Level0)
123 {
124 ASSERT_NE(hiplayer_, nullptr);
125 hiplayer_->isNetWorkPlay_ = true;
126 string name = "testname";
127 FilterType type = FilterType::VIDEO_CAPTURE;
128 hiplayer_->demuxer_ = std::make_shared<DemuxerFilter>(name, type);
129 hiplayer_->demuxer_->demuxer_ = std::make_shared<MediaDemuxer>();
130 hiplayer_->DoInitializeForHttp();
131 EXPECT_NE(hiplayer_->isNetWorkPlay_, false);
132 }
133
134 // @tc.name Test ReportAudioInterruptEvent API
135 // @tc.number PHIUT_ReportAudioInterruptEvent_001
136 // @tc.desc Test ReportAudioInterruptEvent interface, 1.
137 HWTEST_F(PlayHiplayerImplUnitTest, PHIUT_ReportAudioInterruptEvent_001, TestSize.Level0)
138 {
139 ASSERT_NE(hiplayer_, nullptr);
140 hiplayer_->interruptNotifyPlay_.store(true);
141 hiplayer_->ReportAudioInterruptEvent();
142 EXPECT_EQ(hiplayer_->isNetWorkPlay_, false);
143 }
144
145 // @tc.name Test Seek API
146 // @tc.number PHIUT_Seek_001
147 // @tc.desc Test Seek interface, 2.
148 HWTEST_F(PlayHiplayerImplUnitTest, PHIUT_Seek_001, TestSize.Level0)
149 {
150 ASSERT_NE(hiplayer_, nullptr);
151 int32_t mSeconds = 5;
152 PlayerSeekMode mode = PlayerSeekMode::SEEK_NEXT_SYNC;
153 hiplayer_->endTimeWithMode_ = 0;
154 hiplayer_->startTimeWithMode_ = 10;
155 int32_t ret = hiplayer_->Seek(mSeconds, mode);
156 EXPECT_NE(ret, 0);
157 }
158
159 // @tc.name Test NeedSeekClosest API
160 // @tc.number PHIUT_NeedSeekClosest_001
161 // @tc.desc Test Seek NeedSeekClosest, 2.
162 HWTEST_F(PlayHiplayerImplUnitTest, PHIUT_NeedSeekClosest_001, TestSize.Level0)
163 {
164 ASSERT_NE(hiplayer_, nullptr);
165 std::string name = "testname";
166 FilterType type = FilterType::VIDEO_CAPTURE;
167 hiplayer_->demuxer_ = std::make_shared<DemuxerFilter>(name, type);
168 std::shared_ptr<Meta> testptr = std::make_shared<Meta>();
169 hiplayer_->demuxer_->demuxer_ = std::make_shared<MediaDemuxer>();
170 hiplayer_->demuxer_->demuxer_->mediaMetaData_.trackMetas.push_back(testptr);
171 bool ret = hiplayer_->NeedSeekClosest();
172 EXPECT_NE(ret, false);
173 }
174
175 // @tc.name Test SetVolumeMode API
176 // @tc.number PHIUT_SetVolumMode_001
177 // @tc.desc Test SetVolumeMode interface, 1.
178 HWTEST_F(PlayHiplayerImplUnitTest, PHIUT_SetVolumeMode_001, TestSize.Level0)
179 {
180 ASSERT_NE(hiplayer_, nullptr);
181 int32_t mode = 10;
182 std::string name = "testname";
183 hiplayer_->audioSink_ = std::make_shared<AudioSinkFilter>(name);
184 int32_t ret = hiplayer_->SetVolumeMode(mode);
185 EXPECT_EQ(ret, 0);
186 }
187
188 // @tc.name Test SetVolume API
189 // @tc.number PHIUT_SetVolume_001
190 // @tc.desc Test SetVolume interface, 1.
191 HWTEST_F(PlayHiplayerImplUnitTest, PHIUT_SetVolume_001, TestSize.Level0)
192 {
193 ASSERT_NE(hiplayer_, nullptr);
194 float leftVolume = 0.5f;
195 float rightVolume = 0.5f;
196 std::string name = "testname";
197 hiplayer_->audioSink_ = std::make_shared<AudioSinkFilter>(name);
198 int32_t ret = hiplayer_->SetVolume(leftVolume, rightVolume);
199 EXPECT_NE(ret, -7);
200 }
201
202 // @tc.name Test SetDecryptConfig API
203 // @tc.number PHIUT_SetDecryptConfig_001
204 // @tc.desc Test SetDecryptConfig interface, 1.
205 HWTEST_F(PlayHiplayerImplUnitTest, PHIUT_SetDecryptConfig_001, TestSize.Level0)
206 {
207 ASSERT_NE(hiplayer_, nullptr);
208 sptr<OHOS::DrmStandard::IMediaKeySessionService> keySessionProxy;
209 bool svp = false;
210 int32_t ret = hiplayer_->SetDecryptConfig(keySessionProxy, svp);
211 EXPECT_EQ(ret, -7);
212 }
213
214 // @tc.name Test InitDuration API
215 // @tc.number PHIUT_InitDuration_001
216 // @tc.desc Test InitDuration interface, 3.
217 HWTEST_F(PlayHiplayerImplUnitTest, PHIUT_InitDuration_001, TestSize.Level0)
218 {
219 ASSERT_NE(hiplayer_, nullptr);
220 std::string name = "testname";
221 hiplayer_->audioSink_ = std::make_shared<AudioSinkFilter>(name);
222 hiplayer_->audioSink_->audioSink_ = std::make_shared<AudioSink>();
223 int32_t ret = hiplayer_->InitDuration();
224 EXPECT_NE(ret, 0);
225 }
226
227 // @tc.name Test OnEventContinue API
228 // @tc.number PHIUT_OnEventContinue_001
229 // @tc.desc Test OnEventContinue interface, 3.
230 HWTEST_F(PlayHiplayerImplUnitTest, PHIUT_OnEventContinue_001, TestSize.Level0)
231 {
232 ASSERT_NE(hiplayer_, nullptr);
233 Event event;
234 event.type = EventType::EVENT_RESOLUTION_CHANGE;
235 std::string name = "testname";
236 FilterType type = FilterType::VIDEO_CAPTURE;
237 hiplayer_->demuxer_ = std::make_shared<DemuxerFilter>(name, type);
238 std::shared_ptr<Meta> testptr = std::make_shared<Meta>();
239 hiplayer_->demuxer_->demuxer_ = std::make_shared<MediaDemuxer>();
240 hiplayer_->demuxer_->demuxer_->mediaMetaData_.trackMetas.push_back(testptr);
241 Format format;
242 format.meta_ = std::make_shared<Meta>();
243 event.param = format;
244 hiplayer_->OnEventContinue(event);
245
246 event.type = EventType::EVENT_SEI_INFO;
247 hiplayer_->OnEventContinue(event);
248
249 event.type = EventType::EVENT_FLV_AUTO_SELECT_BITRATE;
250 hiplayer_->OnEventContinue(event);
251 EXPECT_EQ(hiplayer_->audioSink_, nullptr);
252 }
253
254 // @tc.name Test OnEventSub API
255 // @tc.number PHIUT_OnEventSub_001
256 // @tc.desc Test OnEventSub interface, 4.
257 HWTEST_F(PlayHiplayerImplUnitTest, PHIUT_OnEventSub_001, TestSize.Level0)
258 {
259 ASSERT_NE(hiplayer_, nullptr);
260 Event event;
261 event.type = EventType::EVENT_AUDIO_DEVICE_CHANGE;
262 AudioStandard::AudioDeviceDescriptor test1;
263 AudioStandard::AudioStreamDeviceChangeReason test2;
264 std::pair<AudioStandard::AudioDeviceDescriptor, AudioStandard::AudioStreamDeviceChangeReason> p1(test1, test2);
265 event.param = p1;
266 hiplayer_->OnEventSub(event);
267
268 event.type = EventType::BUFFERING_END;
269 hiplayer_->isBufferingStartNotified_.store(true);
270 hiplayer_->isSeekClosest_.store(false);
271 int32_t test3 = 10;
272 event.param = test3;
273 hiplayer_->OnEventSub(event);
274
275 event.type = EventType::BUFFERING_START;
276 hiplayer_->isBufferingStartNotified_.store(true);
277 hiplayer_->OnEventSub(event);
278
279 event.type = EventType::EVENT_SOURCE_BITRATE_START;
280 uint32_t test4 = 10;
281 event.param = test4;
282 hiplayer_->OnEventSub(event);
283 EXPECT_EQ(hiplayer_->audioSink_, nullptr);
284 }
285
286 // @tc.name Test OnEventSubTrackChange API
287 // @tc.number PHIUT_OnEventSubTrackChange_001
288 // @tc.desc Test OnEventSubTrackChange interface, 2.
289 HWTEST_F(PlayHiplayerImplUnitTest, PHIUT_OnEventSubTrackChange_001, TestSize.Level0)
290 {
291 ASSERT_NE(hiplayer_, nullptr);
292 Event event;
293 int32_t test1 = 10;
294 std::string name = "testname";
295 FilterType type = FilterType::VIDEO_CAPTURE;
296 hiplayer_->demuxer_ = std::make_shared<DemuxerFilter>(name, type);
297 std::shared_ptr<Meta> testptr = std::make_shared<Meta>();
298 hiplayer_->demuxer_->demuxer_ = std::make_shared<MediaDemuxer>();
299 hiplayer_->demuxer_->demuxer_->mediaMetaData_.trackMetas.push_back(testptr);
300 event.param = test1;
301 event.type = EventType::EVENT_VIDEO_TRACK_CHANGE;
302 hiplayer_->OnEventSubTrackChange(event);
303
304 event.type = EventType::EVENT_SUBTITLE_TRACK_CHANGE;
305 hiplayer_->subtitleSink_ = std::make_shared<SubtitleSinkFilter>("test");
306 hiplayer_->OnEventSubTrackChange(event);
307 EXPECT_EQ(hiplayer_->audioSink_, nullptr);
308 }
309
310 // @tc.name Test DoSetSource API
311 // @tc.number PHIUT_DoSetSource_001
312 // @tc.desc Test DoSetSource interface, 2.
313 HWTEST_F(PlayHiplayerImplUnitTest, PHIUT_DoSetSource_001, TestSize.Level0)
314 {
315 ASSERT_NE(hiplayer_, nullptr);
316 std::string url = "";
317 hiplayer_->mimeType_ = "testtype";
318 AVPlayMediaStream avplayMediaStream;
319 hiplayer_->playMediaStreamVec_.push_back(avplayMediaStream);
320 std::shared_ptr<MediaSource> source = std::make_shared<MediaSource>(url);
321 hiplayer_->DoSetSource(source);
322 EXPECT_EQ(hiplayer_->audioSink_, nullptr);
323 }
324
325 // @tc.name Test HandleDrmInfoUpdatedEvent API
326 // @tc.number PHIUT_HandleDrmInfoUpdatedEvent_001
327 // @tc.desc Test HandleDrmInfoUpdatedEvent interface, 1.
328 HWTEST_F(PlayHiplayerImplUnitTest, PHIUT_HandleDrmInfoUpdatedEvent_001, TestSize.Level0)
329 {
330 ASSERT_NE(hiplayer_, nullptr);
331 Event event;
332 std::multimap<std::string, std::vector<uint8_t>> test1;
333 event.param = test1;
334 hiplayer_->HandleDrmInfoUpdatedEvent(event);
335 EXPECT_EQ(hiplayer_->audioSink_, nullptr);
336 }
337
338 // @tc.name Test HandleResolutionChangeEvent API
339 // @tc.number PHIUT_HandleResolutionChangeEvent_001
340 // @tc.desc Test HandleResolutionChangeEvent interface, 4.
341 HWTEST_F(PlayHiplayerImplUnitTest, PHIUT_HandleResolutionChangeEvent_001, TestSize.Level0)
342 {
343 #ifdef SUPPORT_VIDEO
344 #undef SUPPORT_VIDEO
345 #endif
346 #define SUPPORT_VIDEO
347 ASSERT_NE(hiplayer_, nullptr);
348 Event event;
349 Format format;
350 format.meta_ = std::make_shared<Meta>();
351 event.param = format;
352 std::string name = "testname";
353 FilterType type = FilterType::VIDEO_CAPTURE;
354 hiplayer_->demuxer_ = std::make_shared<DemuxerFilter>(name, type);
355 std::shared_ptr<Meta> testptr = std::make_shared<Meta>();
356 hiplayer_->demuxer_->demuxer_ = std::make_shared<MediaDemuxer>();
357 hiplayer_->demuxer_->demuxer_->mediaMetaData_.trackMetas.push_back(testptr);
358 hiplayer_->currentVideoTrackId_ = 0;
359 hiplayer_->HandleResolutionChangeEvent(event);
360 EXPECT_EQ(hiplayer_->audioSink_, nullptr);
361 #undef SUPPORT_VIDEO
362 }
363
364 // @tc.name Test NotifySeekDone API
365 // @tc.number PHIUT_NotifySeekDone_001
366 // @tc.desc Test NotifySeekDone interface, 1.
367 HWTEST_F(PlayHiplayerImplUnitTest, PHIUT_NotifySeekDone_001, TestSize.Level0)
368 {
369 ASSERT_NE(hiplayer_, nullptr);
370 hiplayer_->curState_ = PlayerStateId::INIT;
371 std::string name = "testname";
372 int32_t testValue = 0;
373 FilterType type = FilterType::VIDEO_CAPTURE;
374 hiplayer_->demuxer_ = std::make_shared<DemuxerFilter>(name, type);
375 std::shared_ptr<Meta> testptr = std::make_shared<Meta>();
376 hiplayer_->demuxer_->demuxer_ = std::make_shared<MediaDemuxer>();
377 hiplayer_->demuxer_->demuxer_->mediaMetaData_.trackMetas.push_back(testptr);
378 hiplayer_->isSeekClosest_.store(true);
379 hiplayer_->isBufferingStartNotified_.store(true);
380 hiplayer_->NotifySeekDone(testValue);
381 EXPECT_NE(hiplayer_->isSeekClosest_.load(), true);
382 }
383
384 // @tc.name Test HandleVideoTrackChangeEvent API
385 // @tc.number PHIUT_HandleVideoTrackChangeEvent_001
386 // @tc.desc Test HandleVideoTrackChangeEvent interface, 2.
387 HWTEST_F(PlayHiplayerImplUnitTest, PHIUT_HandleVideoTrackChangeEvent_001, TestSize.Level0)
388 {
389 #define SUPPORT_VIDEO
390 ASSERT_NE(hiplayer_, nullptr);
391 std::string name = "testname";
392 FilterType type = FilterType::VIDEO_CAPTURE;
393 hiplayer_->demuxer_ = std::make_shared<DemuxerFilter>(name, type);
394 std::shared_ptr<Meta> testptr = std::make_shared<Meta>();
395 hiplayer_->demuxer_->demuxer_ = std::make_shared<MediaDemuxer>();
396 hiplayer_->demuxer_->demuxer_->mediaMetaData_.trackMetas.push_back(testptr);
397 Event event;
398 Format format;
399 format.meta_ = std::make_shared<Meta>();
400 event.param = format;
401 hiplayer_->HandleVideoTrackChangeEvent(event);
402 EXPECT_NE(hiplayer_->isSeekClosest_.load(), true);
403 hiplayer_->demuxer_ = nullptr;
404 #undef SUPPORT_VIDEO
405 }
406
407 // @tc.name Test OnStateChanged API
408 // @tc.number PHIUT_OnStateChanged_001
409 // @tc.desc Test OnStateChanged interface, 1.
410 HWTEST_F(PlayHiplayerImplUnitTest, PHIUT_OnStateChanged_001, TestSize.Level0)
411 {
412 ASSERT_NE(hiplayer_, nullptr);
413 hiplayer_->isDoCompletedSeek_.store(false);
414 hiplayer_->curState_ = PlayerStateId::EOS;
415 PlayerStateId state = PlayerStateId::PAUSE;
416 bool isSystemOperation = false;
417 hiplayer_->OnStateChanged(state, isSystemOperation);
418 EXPECT_NE(hiplayer_->isSeekClosest_.load(), true);
419 }
420
421 // @tc.name Test OnCallback API
422 // @tc.number PHIUT_OnCallback_001
423 // @tc.desc Test OnCallback interface, 2.
424 HWTEST_F(PlayHiplayerImplUnitTest, PHIUT_OnCallback_001, TestSize.Level0)
425 {
426 ASSERT_NE(hiplayer_, nullptr);
427 std::shared_ptr<Filter> filter;
428 FilterCallBackCommand cmd = FilterCallBackCommand::NEXT_FILTER_NEEDED;
429 StreamType outType = StreamType::STREAMTYPE_RAW_VIDEO;
430 Status ret = hiplayer_->OnCallback(filter, cmd, outType);
431 EXPECT_EQ(ret, Status::OK);
432 }
433
434 // @tc.name Test SetAudioRendererParameter API
435 // @tc.number PHIUT_SetAudioRendererParameter_001
436 // @tc.desc Test SetAudioRendererParameter interface, 1.
437 HWTEST_F(PlayHiplayerImplUnitTest, PHIUT_SetAudioRendererParameter_001, TestSize.Level0)
438 {
439 ASSERT_NE(hiplayer_, nullptr);
440 std::string name = "testname";
441 hiplayer_->audioSink_ = std::make_shared<AudioSinkFilter>(name);
442 hiplayer_->audioInterruptMode_ = std::make_shared<Meta>();;
443 hiplayer_->SetAudioRendererParameter();
444 EXPECT_NE(hiplayer_->isSeekClosest_.load(), true);
445 }
446
447 // @tc.name Test IsInValidSeekTime API
448 // @tc.number PHIUT_IsInValidSeekTime_001
449 // @tc.desc Test if (seekTime > endTimeWithMode_)
450 HWTEST_F(PlayHiplayerImplUnitTest, PHIUT_IsInValidSeekTime_001, TestSize.Level0)
451 {
452 ASSERT_NE(hiplayer_, nullptr);
453 hiplayer_->endTimeWithMode_ = 0;
454 hiplayer_->startTimeWithMode_ = -1;
455 int32_t seekPos = 1;
456 auto mockPipeline = std::make_shared<MockPipeline>();
457 EXPECT_CALL(*mockPipeline, SetPlayRange(_, _)).WillRepeatedly(Return(Status::OK));
458 hiplayer_->pipeline_ = mockPipeline;
459 auto ret = hiplayer_->IsInValidSeekTime(seekPos);
460 EXPECT_EQ(ret, false);
461 }
462
463 // @tc.name Test AddSubSource API
464 // @tc.number PHIUT_AddSubSource_001
465 // @tc.desc Test if (result != MSERR_OK)
466 HWTEST_F(PlayHiplayerImplUnitTest, PHIUT_AddSubSource_001, TestSize.Level0)
467 {
468 ASSERT_NE(hiplayer_, nullptr);
469 std::string uriTest = "file:///path/../testfile.txt";
470 auto ret = hiplayer_->AddSubSource(uriTest);
471 EXPECT_NE(ret, 0);
472 }
473
474 // @tc.name Test SetStartFrameRateOptEnabled API
475 // @tc.number PHIUT_SetStartFrameRateOptEnabled_001
476 // @tc.desc Test all
477 HWTEST_F(PlayHiplayerImplUnitTest, PHIUT_SetStartFrameRateOptEnabled_001, TestSize.Level0)
478 {
479 ASSERT_NE(hiplayer_, nullptr);
480 bool enabled = true;
481 auto ret = hiplayer_->SetStartFrameRateOptEnabled(enabled);
482 EXPECT_EQ(ret, 0);
483 EXPECT_EQ(hiplayer_->isEnableStartFrameRateOpt_, true);
484 }
485
486 // @tc.name Test SetInterruptState API
487 // @tc.number PHIUT_SetInterruptState_001
488 // @tc.desc Test if (isFlvLive_ && bufferDurationForPlaying_ > 0)
489 HWTEST_F(PlayHiplayerImplUnitTest, PHIUT_SetInterruptState_001, TestSize.Level0)
490 {
491 ASSERT_NE(hiplayer_, nullptr);
492 bool isInterruptNeeded = false;
493 hiplayer_->interruptMonitor_ = nullptr;
494 hiplayer_->isDrmProtected_ = false;
495 hiplayer_->isFlvLive_ = true;
496 hiplayer_->bufferDurationForPlaying_ = 1;
497 hiplayer_->SetInterruptState(isInterruptNeeded);
498 EXPECT_EQ(hiplayer_->isInterruptNeeded_, false);
499 }
500
501 // @tc.name Test SelectBitRate API
502 // @tc.number PHIUT_SelectBitRate_002
503 // @tc.desc Test return MSERR_INVALID_OPERATION;
504 HWTEST_F(PlayHiplayerImplUnitTest, PHIUT_SelectBitRate_002, TestSize.Level0)
505 {
506 ASSERT_NE(hiplayer_, nullptr);
507 std::string name = "testname";
508 FilterType type = FilterType::VIDEO_CAPTURE;
509 auto mockDemuxer = std::make_shared<MockDemuxerFilter>(name, type);
510 EXPECT_CALL(*mockDemuxer, SelectBitRate(_, _)).WillRepeatedly(Return(Status::ERROR_INVALID_OPERATION));
511 hiplayer_->demuxer_ = mockDemuxer;
512 uint32_t bitRate = 0;
513 bool isAutoSelect = false;
514 auto ret = hiplayer_->SelectBitRate(bitRate, isAutoSelect);
515 EXPECT_NE(ret, 0);
516 }
517
518 // @tc.name Test DoInitializeForHttp API
519 // @tc.number PHIUT_DoInitializeForHttp_002
520 // @tc.desc Test if (ret == Status::OK && vBitRates.size() > 0)
521 HWTEST_F(PlayHiplayerImplUnitTest, PHIUT_DoInitializeForHttp_002, TestSize.Level0)
522 {
523 ASSERT_NE(hiplayer_, nullptr);
524 std::string name = "testname";
525 FilterType type = FilterType::VIDEO_CAPTURE;
526 auto mockDemuxer = std::make_shared<MockDemuxerFilter>(name, type);
__anona27fe76e0102(std::vector<uint32_t> vBitRates) 527 EXPECT_CALL(*mockDemuxer, GetBitRates(_)).WillRepeatedly(Invoke([](std::vector<uint32_t> vBitRates) {
528 vBitRates.push_back(1);
529 return Status::OK;
530 }));
531 hiplayer_->demuxer_ = mockDemuxer;
532 hiplayer_->isNetWorkPlay_ = false;
533 hiplayer_->DoInitializeForHttp();
534 EXPECT_EQ(hiplayer_->isInterruptNeeded_, false);
535 }
536
537 // @tc.name Test SetVolumeMode API
538 // @tc.number PHIUT_SetVolumeMode_002
539 // @tc.desc Test if (ret != Status::OK)
540 HWTEST_F(PlayHiplayerImplUnitTest, PHIUT_SetVolumeMode_002, TestSize.Level0)
541 {
542 ASSERT_NE(hiplayer_, nullptr);
543 int32_t mode = 10;
544 std::string name = "testname";
545 auto mockAudioSink = std::make_shared<MockAudioSinkFilter>(name, FilterType::VIDEO_CAPTURE);
546 EXPECT_CALL(*mockAudioSink, SetVolumeMode(_)).WillRepeatedly(Return(Status::ERROR_NULL_POINTER));
547 hiplayer_->audioSink_ = mockAudioSink;
548 auto ret = hiplayer_->SetVolumeMode(mode);
549 EXPECT_EQ(ret, 0);
550 }
551
552 // @tc.name Test InnerSelectTrack API
553 // @tc.number PHIUT_InnerSelectTrack_001
554 // @tc.desc Test if (IsSubtitleMime(mime))else if (IsVideoMime(mime))
555 HWTEST_F(PlayHiplayerImplUnitTest, PHIUT_InnerSelectTrack_001, TestSize.Level0)
556 {
557 ASSERT_NE(hiplayer_, nullptr);
558 std::string name = "testname";
559 FilterType type = FilterType::VIDEO_CAPTURE;
560 auto mockDemuxer = std::make_shared<MockDemuxerFilter>(name, type);
561 EXPECT_CALL(*mockDemuxer, SelectTrack(_)).WillRepeatedly(Return(Status::OK));
562 hiplayer_->demuxer_ = mockDemuxer;
563 std::string mime = "text/vtt";
564 int32_t trackId = 1;
565 PlayerSwitchMode mode = PlayerSwitchMode::SWITCH_SEGMENT;
566 hiplayer_->InnerSelectTrack(mime, trackId, mode);
567 }
568
569 // @tc.name Test InnerSelectTrack API
570 // @tc.number PHIUT_InnerSelectTrack_002
571 // @tc.desc Test mode == PlayerSwitchMode::SWITCH_SEGMENT & mode == PlayerSwitchMode::SWITCH_CLOSEST
572 HWTEST_F(PlayHiplayerImplUnitTest, PHIUT_InnerSelectTrack_002, TestSize.Level0)
573 {
574 ASSERT_NE(hiplayer_, nullptr);
575 std::string name = "testname";
576 FilterType type = FilterType::VIDEO_CAPTURE;
577 auto mockDemuxer = std::make_shared<MockDemuxerFilter>(name, type);
578 EXPECT_CALL(*mockDemuxer, SelectTrack(_)).WillRepeatedly(Return(Status::OK));
579 hiplayer_->demuxer_ = mockDemuxer;
580 std::string mime = "video/test";
581 int32_t trackId = 1;
582 PlayerSwitchMode mode = PlayerSwitchMode::SWITCH_SEGMENT;
583 hiplayer_->curState_ = PlayerStateId::EOS;
584 auto ret = hiplayer_->InnerSelectTrack(mime, trackId, mode);
585 EXPECT_NE(ret, MSERR_OK);
586 mode = PlayerSwitchMode::SWITCH_CLOSEST;
587 ret = hiplayer_->InnerSelectTrack(mime, trackId, mode);
588 EXPECT_NE(ret, MSERR_OK);
589 }
590
591 // @tc.name Test SelectTrack API
592 // @tc.number PHIUT_SelectTrack_001
593 // @tc.desc Test return MSERR_UNKNOWN;
594 HWTEST_F(PlayHiplayerImplUnitTest, PHIUT_SelectTrack_001, TestSize.Level0)
595 {
596 ASSERT_NE(hiplayer_, nullptr);
597 std::shared_ptr<Meta> meta1 = std::make_shared<Meta>();
598 meta1->SetData(Tag::MIME_TYPE, "test/invailed");
599 std::vector<std::shared_ptr<Meta>> metaInfo;
600 metaInfo.push_back(meta1);
601 std::string name = "testname";
602 FilterType type = FilterType::VIDEO_CAPTURE;
603 auto mockDemuxer = std::make_shared<MockDemuxerFilter>(name, type);
604 EXPECT_CALL(*mockDemuxer, GetStreamMetaInfo()).WillRepeatedly(Return(metaInfo));
605 hiplayer_->demuxer_ = mockDemuxer;
606 int32_t trackId = 0;
607 PlayerSwitchMode mode = PlayerSwitchMode::SWITCH_SEGMENT;
608 auto ret = hiplayer_->SelectTrack(trackId, mode);
609 EXPECT_NE(ret, MSERR_OK);
610 }
611
612 // @tc.name Test GetSubtitleTrackInfo API
613 // @tc.number PHIUT_GetSubtitleTrackInfo_001
614 // @tc.desc Test !(trackInfo->GetData(Tag::MIME_TYPE, mime))||mime.find("invalid") == 0)if(IsSubtitleMime(mime))
615 HWTEST_F(PlayHiplayerImplUnitTest, PHIUT_GetSubtitleTrackInfo_001, TestSize.Level0)
616 {
617 ASSERT_NE(hiplayer_, nullptr);
618 std::shared_ptr<Meta> meta1 = std::make_shared<Meta>();
619 meta1->SetData(Tag::MIME_TYPE, "test/invailed");
620 std::shared_ptr<Meta> meta2 = std::make_shared<Meta>();
621 meta2->SetData(Tag::MIME_TYPE, "text/vtt");
622 std::vector<std::shared_ptr<Meta>> metaInfo;
623 metaInfo.push_back(meta2);
624 metaInfo.push_back(meta1);
625 std::string name = "testname";
626 FilterType type = FilterType::VIDEO_CAPTURE;
627 auto mockDemuxer = std::make_shared<MockDemuxerFilter>(name, type);
628 EXPECT_CALL(*mockDemuxer, GetStreamMetaInfo()).WillRepeatedly(Return(metaInfo));
629 hiplayer_->demuxer_ = mockDemuxer;
630 std::vector<Format> subtitleTrack;
631 auto ret = hiplayer_->GetSubtitleTrackInfo(subtitleTrack);
632 EXPECT_EQ(ret, MSERR_OK);
633 }
634
635 // @tc.name Test HandleAudioTrackChangeEvent API
636 // @tc.number PHIUT_HandleAudioTrackChangeEvent_001
637 // @tc.desc Test if (!(metaInfo[trackId]->GetData(Tag::MIME_TYPE, mime)))
638 HWTEST_F(PlayHiplayerImplUnitTest, PHIUT_HandleAudioTrackChangeEvent_001, TestSize.Level0)
639 {
640 ASSERT_NE(hiplayer_, nullptr);
641 std::shared_ptr<Meta> meta1 = std::make_shared<Meta>();
642 std::vector<std::shared_ptr<Meta>> metaInfo;
643 metaInfo.push_back(meta1);
644 Event event;
645 event.param = 0;
646 std::string name = "testname";
647 FilterType type = FilterType::VIDEO_CAPTURE;
648 auto mockDemuxer = std::make_shared<MockDemuxerFilter>(name, type);
649 EXPECT_CALL(*mockDemuxer, GetStreamMetaInfo()).WillRepeatedly(Return(metaInfo));
650 hiplayer_->demuxer_ = mockDemuxer;
651 hiplayer_->HandleAudioTrackChangeEvent(event);
652 EXPECT_NE(metaInfo.size(), 0);
653 }
654
655 // @tc.name Test HandleVideoTrackChangeEvent API
656 // @tc.number PHIUT_HandleAudioTrackChangeEvent_002
657 // @tc.desc Test if (Status::OK != demuxer_->StartTask(trackId))
658 HWTEST_F(PlayHiplayerImplUnitTest, PHIUT_HandleAudioTrackChangeEvent_002, TestSize.Level0)
659 {
660 ASSERT_NE(hiplayer_, nullptr);
661 std::shared_ptr<Meta> meta1 = std::make_shared<Meta>();
662 meta1->SetData(Tag::MIME_TYPE, "video/test");
663 std::vector<std::shared_ptr<Meta>> metaInfo;
664 metaInfo.push_back(meta1);
665 Event event;
666 event.param = 0;
667 std::string name = "testname";
668 FilterType type = FilterType::VIDEO_CAPTURE;
669 auto mockDemuxer = std::make_shared<MockDemuxerFilter>(name, type);
670 EXPECT_CALL(*mockDemuxer, GetStreamMetaInfo()).WillRepeatedly(Return(metaInfo));
671 EXPECT_CALL(*mockDemuxer, StartTask(_)).WillRepeatedly(Return(Status::ERROR_INVALID_OPERATION));
672 hiplayer_->demuxer_ = mockDemuxer;
673 hiplayer_->HandleVideoTrackChangeEvent(event);
674 }
675
676 // @tc.name Test HandleSubtitleTrackChangeEvent API
677 // @tc.number PHIUT_HandleSubtitleTrackChangeEvent_001
678 // @tc.desc Test if (!(metaInfo[trackId]->GetData(Tag::MIME_TYPE, mime)))
679 HWTEST_F(PlayHiplayerImplUnitTest, PHIUT_HandleSubtitleTrackChangeEvent_001, TestSize.Level0)
680 {
681 ASSERT_NE(hiplayer_, nullptr);
682 std::shared_ptr<Meta> meta1 = std::make_shared<Meta>();
683 std::vector<std::shared_ptr<Meta>> metaInfo;
684 metaInfo.push_back(meta1);
685 Event event;
686 event.param = 0;
687 std::string name = "testname";
688 FilterType type = FilterType::VIDEO_CAPTURE;
689 auto mockDemuxer = std::make_shared<MockDemuxerFilter>(name, type);
690 EXPECT_CALL(*mockDemuxer, GetStreamMetaInfo()).WillRepeatedly(Return(metaInfo));
691 EXPECT_CALL(*mockDemuxer, StartTask(_)).WillRepeatedly(Return(Status::ERROR_INVALID_OPERATION));
692 hiplayer_->demuxer_ = mockDemuxer;
693 hiplayer_->HandleSubtitleTrackChangeEvent(event);
694 }
695
696 // @tc.name Test OnCallback API
697 // @tc.number PHIUT_OnCallback_002
698 // @tc.desc Test default
699 HWTEST_F(PlayHiplayerImplUnitTest, PHIUT_OnCallback_002, TestSize.Level0)
700 {
701 ASSERT_NE(hiplayer_, nullptr);
702 std::string name = "testname";
703 auto mockFilter = std::make_shared<MockFilter>();
704 std::shared_ptr<Filter> filter = mockFilter;
705 FilterCallBackCommand cmd = FilterCallBackCommand::NEXT_FILTER_NEEDED;
706 StreamType outType = StreamType::STREAMTYPE_MAX;
707 auto ret = hiplayer_->OnCallback(filter, cmd, outType);
708 EXPECT_EQ(ret, Status::OK);
709 }
710
711 // @tc.name Test DoRestartLiveLink API
712 // @tc.number PHIUT_DoRestartLiveLink_001
713 // @tc.desc Test audioDecoder_ == nullptr && audioSink_ == nullptr && videoDecoder_ == nullptr
714 HWTEST_F(PlayHiplayerImplUnitTest, PHIUT_DoRestartLiveLink_001, TestSize.Level0)
715 {
716 ASSERT_NE(hiplayer_, nullptr);
717 hiplayer_->isFlvLive_ = true;
718 std::string name = "testname";
719 FilterType type = FilterType::VIDEO_CAPTURE;
720 auto mockDemuxer = std::make_shared<MockDemuxerFilter>(name, type);
721 EXPECT_CALL(*mockDemuxer, DoFlush()).WillOnce(Return(Status::OK));
722 hiplayer_->demuxer_ = mockDemuxer;
723 hiplayer_->audioSink_ = nullptr;
724 hiplayer_->videoDecoder_ = nullptr;
725 hiplayer_->audioDecoder_ = nullptr;
726
727 hiplayer_->DoRestartLiveLink();
728 }
729
730 // @tc.name Test DoRestartLiveLink API
731 // @tc.number PHIUT_DoRestartLiveLink_002
732 // @tc.desc Test audioDecoder_ != nullptr && audioSink_ != nullptr && videoDecoder_ != nullptr
733 HWTEST_F(PlayHiplayerImplUnitTest, PHIUT_DoRestartLiveLink_002, TestSize.Level0)
734 {
735 ASSERT_NE(hiplayer_, nullptr);
736 hiplayer_->isFlvLive_ = true;
737 std::string name = "testname";
738 FilterType type = FilterType::VIDEO_CAPTURE;
739 auto mockDemuxer = std::make_shared<MockDemuxerFilter>(name, type);
740 EXPECT_CALL(*mockDemuxer, DoFlush()).WillOnce(Return(Status::OK));
741 hiplayer_->demuxer_ = mockDemuxer;
742 auto mockAudioSink = std::make_shared<MockAudioSinkFilter>(name, FilterType::VIDEO_CAPTURE);
743 EXPECT_CALL(*mockAudioSink, DoFlush()).WillOnce(Return(Status::OK));
744 EXPECT_CALL(*mockAudioSink, DoStart()).WillOnce(Return(Status::OK));
745 hiplayer_->audioSink_ = mockAudioSink;
746 auto mockVideoDemuxer = std::make_shared<DecoderSurfaceFilter>(name, type);
747 EXPECT_CALL(*mockVideoDemuxer, DoFlush()).WillOnce(Return(Status::OK));
748 EXPECT_CALL(*mockVideoDemuxer, DoStart()).WillOnce(Return(Status::OK));
749 hiplayer_->videoDecoder_ = mockVideoDemuxer;
750 auto mockAudioDecoder = std::make_shared<AudioDecoderFilter>(name, type);
751 EXPECT_CALL(*mockAudioDecoder, DoFlush()).WillOnce(Return(Status::OK));
752 EXPECT_CALL(*mockAudioDecoder, DoStart()).WillOnce(Return(Status::OK));
753 hiplayer_->audioDecoder_ = mockAudioDecoder;
754
755 hiplayer_->DoRestartLiveLink();
756 }
757
758 // @tc.name Test SetReopenFd API
759 // @tc.number PHIUT_SetReopenFd_001
760 // @tc.desc Test all
761 HWTEST_F(PlayHiplayerImplUnitTest, PHIUT_SetReopenFd_001, TestSize.Level0)
762 {
763 ASSERT_NE(hiplayer_, nullptr);
764 int32_t fd = 0;
765
766 int32_t ret = hiplayer_->SetReopenFd(fd);
767 EXPECT_EQ(ret, 0);
768 }
769
770 // @tc.name Test EnableCameraPostprocessing API
771 // @tc.number PHIUT_EnableCameraPostprocessing_001
772 // @tc.desc Test all
773 HWTEST_F(PlayHiplayerImplUnitTest, PHIUT_EnableCameraPostprocessing_001, TestSize.Level0)
774 {
775 ASSERT_NE(hiplayer_, nullptr);
776 hiplayer_->enableCameraPostprocessing_ = true;
777
778 int32_t ret = hiplayer_->EnableCameraPostprocessing();
779 EXPECT_EQ(ret, 0);
780 }
781
782 // @tc.name Test SetSeiMessageListener API
783 // @tc.number PHIUT_SetSeiMessageListener_001
784 // @tc.desc Test !(videoDecoder_ != nullptr && surface_ != nullptr)
785 HWTEST_F(PlayHiplayerImplUnitTest, PHIUT_SetSeiMessageListener_001, TestSize.Level0)
786 {
787 ASSERT_NE(hiplayer_, nullptr);
788 hiplayer_->videoDecoder_ = nullptr;
789 hiplayer_->surface_ = nullptr;
790
791 auto ret = hiplayer_->SetSeiMessageListener();
792 EXPECT_EQ(ret, Status::OK);
793
794 std::string name = "testname";
795 FilterType type = FilterType::VIDEO_CAPTURE;
796 auto mockVideoDemuxer = std::make_shared<DecoderSurfaceFilter>(name, type);
797 hiplayer_->videoDecoder_ = mockVideoDemuxer;
798 hiplayer_->surface_ = nullptr;
799 ret = hiplayer_->SetSeiMessageListener();
800 EXPECT_EQ(ret, Status::OK);
801
802 auto mockCodecSurface = sptr<MockCodecSurface>(new MockCodecSurface());
803 hiplayer_->surface_ = mockCodecSurface;
804 hiplayer_->videoDecoder_ = nullptr;
805 ret = hiplayer_->SetSeiMessageListener();
806 EXPECT_EQ(ret, Status::OK);
807 }
808
809 // @tc.name Test SetSeiMessageListener API
810 // @tc.number PHIUT_SetSeiMessageListener_002
811 // @tc.desc Test !(seiDecoder_ != nullptr && surface_ == nullptr)
812 HWTEST_F(PlayHiplayerImplUnitTest, PHIUT_SetSeiMessageListener_002, TestSize.Level0)
813 {
814 ASSERT_NE(hiplayer_, nullptr);
815 hiplayer_->surface_ = nullptr;
816 hiplayer_->seiDecoder_ = nullptr;
817 auto ret = hiplayer_->SetSeiMessageListener();
818 EXPECT_EQ(ret, Status::OK);
819
820 std::string name = "testname";
821 FilterType type = FilterType::VIDEO_CAPTURE;
822 auto mockSeiDecoder = std::make_shared<SeiParserFilter>(name, type);
823 hiplayer_->seiDecoder_ = mockSeiDecoder;
824 auto mockCodecSurface = sptr<MockCodecSurface>(new MockCodecSurface());
825 hiplayer_->surface_ = mockCodecSurface;
826 ret = hiplayer_->SetSeiMessageListener();
827 EXPECT_EQ(ret, Status::OK);
828
829 hiplayer_->seiDecoder_ = nullptr;
830 mockCodecSurface = sptr<MockCodecSurface>(new MockCodecSurface());
831 hiplayer_->surface_ = mockCodecSurface;
832 ret = hiplayer_->SetSeiMessageListener();
833 EXPECT_EQ(ret, Status::OK);
834 }
835
836 // @tc.name Test LinkSeiDecoder API
837 // @tc.number PHIUT_LinkSeiDecoder_001
838 // @tc.desc Test seiDecoder_ != nullptr
839 HWTEST_F(PlayHiplayerImplUnitTest, PHIUT_LinkSeiDecoder_001, TestSize.Level0)
840 {
841 ASSERT_NE(hiplayer_, nullptr);
842 std::string name = "testname";
843 FilterType type = FilterType::VIDEO_CAPTURE;
844 auto mockSeiDecoder = std::make_shared<SeiParserFilter>(name, type);
845 hiplayer_->seiDecoder_ = mockSeiDecoder;
846 auto mockFilter = std::make_shared<MockFilter>();
847 std::shared_ptr<Filter> preFilter = mockFilter;
848 auto ret = hiplayer_->LinkSeiDecoder(preFilter, StreamType::STREAMTYPE_ENCODED_AUDIO);
849 EXPECT_EQ(ret, Status::OK);
850 }
851
852 // @tc.name Test IsLiveStream API
853 // @tc.number PHIUT_IsLiveStream_001
854 // @tc.desc Test all
855 HWTEST_F(PlayHiplayerImplUnitTest, PHIUT_IsLiveStream_001, TestSize.Level0)
856 {
857 ASSERT_NE(hiplayer_, nullptr);
858 std::string name = "testname";
859 FilterType type = FilterType::VIDEO_CAPTURE;
860 auto mockDemuxer = std::make_shared<MockDemuxerFilter>(name, type);
861 hiplayer_->demuxer_ = mockDemuxer;
862 auto ret = hiplayer_->IsLiveStream();
863 EXPECT_EQ(ret, false);
864 }
865
866 // @tc.name Test ResumeDemuxer API
867 // @tc.number PHIUT_ResumeDemuxer_001
868 // @tc.desc Test all
869 HWTEST_F(PlayHiplayerImplUnitTest, PHIUT_ResumeDemuxer_001, TestSize.Level0)
870 {
871 ASSERT_NE(hiplayer_, nullptr);
872 hiplayer_->pipelineStates_ = PlayerStates::PLAYER_STATE_ERROR;
873
874 auto ret = hiplayer_->ResumeDemuxer();
875 EXPECT_EQ(ret, 0);
876 }
877
878 // @tc.name Test HandleSeek API
879 // @tc.number PHIUT_HandleSeek_001
880 // @tc.desc Test case PlayerStates::PLAYER_FROZEN
881 HWTEST_F(PlayHiplayerImplUnitTest, PHIUT_HandleSeek_001, TestSize.Level0)
882 {
883 ASSERT_NE(hiplayer_, nullptr);
884 hiplayer_->pipelineStates_ = PlayerStates::PLAYER_FROZEN;
885 auto mockPipeline = std::make_shared<MockPipeline>();
886 hiplayer_->pipeline_ = mockPipeline;
887 std::string name = "testname";
888 FilterType type = FilterType::VIDEO_CAPTURE;
889 auto mockDemuxer = std::make_shared<MockDemuxerFilter>(name, type);
890 hiplayer_->demuxer_ = mockDemuxer;
891 auto ret = hiplayer_->HandleSeek(0, PlayerSeekMode::SEEK_NEXT_SYNC);
892 EXPECT_EQ(ret, Status::OK);
893 }
894
895 // @tc.name Test doFrozenSeek API
896 // @tc.number PHIUT_doFrozenSeek_001
897 // @tc.desc Test isUnFreezeSeek = true
898 HWTEST_F(PlayHiplayerImplUnitTest, PHIUT_doFrozenSeek_001, TestSize.Level0)
899 {
900 ASSERT_NE(hiplayer_, nullptr);
901 std::shared_ptr<Meta> meta1 = std::make_shared<Meta>();
902 meta1->SetData(Tag::MIME_TYPE, "test/invailed");
903 std::shared_ptr<Meta> meta2 = std::make_shared<Meta>();
904 meta2->SetData(Tag::MIME_TYPE, "text/vtt");
905 std::vector<std::shared_ptr<Meta>> metaInfo;
906 metaInfo.push_back(meta2);
907 metaInfo.push_back(meta1);
908 std::string name = "testname";
909 FilterType type = FilterType::VIDEO_CAPTURE;
910 auto mockDemuxer = std::make_shared<MockDemuxerFilter>(name, type);
911 hiplayer_->demuxer_ = mockDemuxer;
912 auto mockPipeline = std::make_shared<MockPipeline>();
913 hiplayer_->pipeline_ = mockPipeline;
914 auto ret = hiplayer_->doFrozenSeek(0, PlayerSeekMode::SEEK_NEXT_SYNC, true);
915 EXPECT_EQ(ret, Status::OK);
916 }
917
918 // @tc.name Test doFrozenSeek API
919 // @tc.number PHIUT_doFrozenSeek_002
920 // @tc.desc Test isUnFreezeSeek = false
921 HWTEST_F(PlayHiplayerImplUnitTest, PHIUT_doFrozenSeek_002, TestSize.Level0)
922 {
923 ASSERT_NE(hiplayer_, nullptr);
924 auto ret = hiplayer_->doFrozenSeek(0, PlayerSeekMode::SEEK_CLOSEST, false);
925 EXPECT_EQ(ret, Status::OK);
926 EXPECT_EQ(hiplayer_->isForzenSeekRecv_, true);
927 }
928
929 // @tc.name Test EnableStartFrameRateOpt API
930 // @tc.number PHIUT_EnableStartFrameRateOpt_001
931 // @tc.desc Test videoTrack.GetDoubleValue("frame_rate", frameRate) && syncManager_ != nullptr
932 HWTEST_F(PlayHiplayerImplUnitTest, PHIUT_EnableStartFrameRateOpt_001, TestSize.Level0)
933 {
934 ASSERT_NE(hiplayer_, nullptr);
935 double frameRate = 1;
936 Format format1;
937 format1.PutDoubleValue("frame_rate", frameRate);
938 hiplayer_->syncManager_ = nullptr;
939 hiplayer_->EnableStartFrameRateOpt(format1);
940 EXPECT_TRUE(format1.GetDoubleValue("frame_rate", frameRate));
941
942 Format format2;
943 format2.PutDoubleValue("frame_rate", 2.0);
944 hiplayer_->EnableStartFrameRateOpt(format2);
945
946 hiplayer_->syncManager_ = std::make_shared<MediaSyncManager>();
947 hiplayer_->EnableStartFrameRateOpt(format2);
948 EXPECT_NE(hiplayer_->syncManager_->videoInitialFrameRate_, 0.01);
949 hiplayer_->EnableStartFrameRateOpt(format1);
950 EXPECT_EQ(hiplayer_->syncManager_->videoInitialFrameRate_, 0.01);
951 }
952
953 // @tc.name Test SetMediaMuted API
954 // @tc.number PHIUT_SetMediaMuted_001
955 // @tc.desc Test SetMediaMuted interface, 1.
956 HWTEST_F(PlayHiplayerImplUnitTest, PHIUT_SetMediaMuted_001, TestSize.Level0)
957 {
958 ASSERT_NE(hiplayer_, nullptr);
959 hiplayer_->audioSink_ = nullptr;
960 int32_t ret = hiplayer_->SetMediaMuted(OHOS::Media::MediaType::MEDIA_TYPE_AUD, true);
961 EXPECT_NE(ret, MSERR_OK);
962
963 std::string name = "testname";
964 hiplayer_->audioSink_ = std::make_shared<AudioSinkFilter>(name);
965 ret = hiplayer_->SetMediaMuted(OHOS::Media::MediaType::MEDIA_TYPE_AUD, true);
966 EXPECT_NE(ret, MSERR_OK);
967 }
968
969 // @tc.name Test SetMediaMuted API
970 // @tc.number PHIUT_SetMediaMuted_002
971 // @tc.desc Test SetMediaMuted interface, 2.
972 HWTEST_F(PlayHiplayerImplUnitTest, PHIUT_SetMediaMuted_002, TestSize.Level0)
973 {
974 ASSERT_NE(hiplayer_, nullptr);
975 std::string name = "testname";
976 FilterType type = FilterType::VIDEO_CAPTURE;
977 hiplayer_->videoDecoder_ = std::make_shared<DecoderSurfaceFilter>(name, type);
978 hiplayer_->demuxer_ = std::make_shared<MockDemuxerFilter>(name, type);
979 int32_t ret = hiplayer_->SetMediaMuted(OHOS::Media::MediaType::MEDIA_TYPE_VID, true);
980 EXPECT_EQ(hiplayer_->isVideoMuted_, true);
981 EXPECT_EQ(ret, MSERR_OK);
982
983 hiplayer_->SetMediaMuted(OHOS::Media::MediaType::MEDIA_TYPE_VID, false);
984 EXPECT_EQ(hiplayer_->isVideoMuted_, false);
985 EXPECT_EQ(ret, MSERR_OK);
986 }
987
988 // @tc.name Test SetMediaMuted API
989 // @tc.number PHIUT_SetMediaMuted_003
990 // @tc.desc Test SetMediaMuted interface, 3.
991 HWTEST_F(PlayHiplayerImplUnitTest, PHIUT_SetMediaMuted_003, TestSize.Level0)
992 {
993 ASSERT_NE(hiplayer_, nullptr);
994 int32_t ret = hiplayer_->SetMediaMuted(OHOS::Media::MediaType::MEDIA_TYPE_SUBTITLE, true);
995 EXPECT_NE(ret, MSERR_OK);
996
997 ret = hiplayer_->SetMediaMuted(OHOS::Media::MediaType::MEDIA_TYPE_SUBTITLE, false);
998 EXPECT_NE(ret, MSERR_OK);
999 }
1000 } // namespace Media
1001 } // namespace OHOS
1002