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 "demuxer_plugin_manager_unittest.h"
17
18 using namespace OHOS;
19 using namespace OHOS::Media;
20 using namespace testing::ext;
21 using namespace testing;
22 using namespace std;
23
24 namespace OHOS {
25 namespace Media {
26 static const int32_t INVALID_NUM = 0;
27 static const int32_t ID_TEST = 0;
28 static const int32_t INVALID_ID = -1;
29 static const int32_t INVALID_TYPE = 5;
30 constexpr int32_t API_VERSION_18 = 18;
SetUpTestCase(void)31 void DemuxerPluginManagerUnittest::SetUpTestCase(void) {}
32
TearDownTestCase(void)33 void DemuxerPluginManagerUnittest::TearDownTestCase(void) {}
34
SetUp(void)35 void DemuxerPluginManagerUnittest::SetUp(void)
36 {
37 demuxerPluginManager_ = std::make_shared<DemuxerPluginManager>();
38 streamDemuxer_ = std::make_shared<MockBaseStreamDemuxer>();
39 int32_t streamId = ID_TEST;
40 dataSourceImpl_ = std::make_shared<DataSourceImpl>(streamDemuxer_, streamId);
41 dataSourceImpl_->stream_ = streamDemuxer_;
42 }
43
TearDown(void)44 void DemuxerPluginManagerUnittest::TearDown(void)
45 {
46 demuxerPluginManager_ = nullptr;
47 streamDemuxer_ = nullptr;
48 dataSourceImpl_ = nullptr;
49 }
50
51 /**
52 * @tc.name : Test IsOffsetValid API
53 * @tc.number: IsOffsetValid_001
54 * @tc.desc : Test stream_->seekable_ != Plugins::Seekable::SEEKABLE
55 */
56 HWTEST_F(DemuxerPluginManagerUnittest, IsOffsetValid_001, TestSize.Level1)
57 {
58 ASSERT_NE(dataSourceImpl_, nullptr);
59 dataSourceImpl_->stream_->seekable_ = Plugins::Seekable::INVALID;
60 size_t offset = INVALID_NUM;
61 auto ret = dataSourceImpl_->IsOffsetValid(offset);
62 EXPECT_EQ(ret, true);
63 }
64
65 /**
66 * @tc.name : Test ReadAt API
67 * @tc.number: ReadAt_001
68 * @tc.desc : Test return Status::ERROR_UNKNOWN
69 */
70 HWTEST_F(DemuxerPluginManagerUnittest, ReadAt_001, TestSize.Level1)
71 {
72 ASSERT_NE(dataSourceImpl_, nullptr);
73 dataSourceImpl_->stream_->seekable_ = Plugins::Seekable::INVALID;
74 int64_t offset = INVALID_NUM;
75 std::shared_ptr<Buffer> buffer;
76 size_t expectedLen = INVALID_NUM;
77 auto ret = dataSourceImpl_->ReadAt(offset, buffer, expectedLen);
78 EXPECT_EQ(ret, Status::ERROR_UNKNOWN);
79 }
80
81 /**
82 * @tc.name : Test InitAudioTrack API
83 * @tc.number: InitAudioTrack_001
84 * @tc.desc : Test apiVersion_ >= API_VERSION_16
85 * Test apiVersion_ >= API_VERSION_18
86 */
87 HWTEST_F(DemuxerPluginManagerUnittest, InitAudioTrack_001, TestSize.Level1)
88 {
89 ASSERT_NE(demuxerPluginManager_, nullptr);
90 StreamInfo info;
91 info.streamId = ID_TEST;
92 demuxerPluginManager_->curAudioStreamID_ = INVALID_NUM;
93 demuxerPluginManager_->apiVersion_ = API_VERSION_18;
94 MediaStreamInfo mediaInfo;
95 demuxerPluginManager_->streamInfoMap_[0] = mediaInfo;
96 demuxerPluginManager_->InitAudioTrack(info);
97 EXPECT_EQ(demuxerPluginManager_->streamInfoMap_[0].mediaInfo.tracks.empty(), false);
98 }
99
100 /**
101 * @tc.name : Test InitVideoTrack API
102 * @tc.number: InitVideoTrack_001
103 * @tc.desc : Test apiVersion_ >= API_VERSION_16
104 * Test apiVersion_ >= API_VERSION_18
105 */
106 HWTEST_F(DemuxerPluginManagerUnittest, InitVideoTrack_001, TestSize.Level1)
107 {
108 ASSERT_NE(demuxerPluginManager_, nullptr);
109 StreamInfo info;
110 info.streamId = ID_TEST;
111 demuxerPluginManager_->curAudioStreamID_ = INVALID_NUM;
112 demuxerPluginManager_->apiVersion_ = API_VERSION_18;
113 MediaStreamInfo mediaInfo;
114 demuxerPluginManager_->streamInfoMap_[0] = mediaInfo;
115 demuxerPluginManager_->InitVideoTrack(info);
116 EXPECT_EQ(demuxerPluginManager_->streamInfoMap_[0].type, VIDEO);
117 }
118
119 /**
120 * @tc.name : Test InitDefaultPlay API
121 * @tc.number: InitDefaultPlay_001
122 * @tc.desc : Test isHlsFmp4_ == true
123 * Test info2.type = INVALID_TYPE
124 */
125 HWTEST_F(DemuxerPluginManagerUnittest, InitDefaultPlay_001, TestSize.Level1)
126 {
127 ASSERT_NE(demuxerPluginManager_, nullptr);
128 StreamInfo info;
129 info.type = MIXED;
130 info.streamId = INVALID_NUM;
131 demuxerPluginManager_->isHlsFmp4_ = true;
132 demuxerPluginManager_->curVideoStreamID_ = INVALID_ID;
133 MediaStreamInfo mediaInfo;
134 demuxerPluginManager_->streamInfoMap_[0] = mediaInfo;
135 std::vector<StreamInfo> streams;
136 streams.push_back(info);
137 StreamInfo info2;
138 info2.type = static_cast<OHOS::Media::Plugins::StreamType>(INVALID_TYPE);
139 info2.streamId = INVALID_NUM;
140 streams.push_back(info2);
141 auto ret = demuxerPluginManager_->InitDefaultPlay(streams);
142 EXPECT_EQ(demuxerPluginManager_->curVideoStreamID_, info.streamId);
143 EXPECT_EQ(demuxerPluginManager_->isDash_, true);
144 EXPECT_EQ(ret, Status::OK);
145 }
146
147 /**
148 * @tc.name : Test GetTrackInfoByStreamID API
149 * @tc.number: GetTrackInfoByStreamID_001
150 * @tc.desc : Test all
151 */
152 HWTEST_F(DemuxerPluginManagerUnittest, GetTrackInfoByStreamID_001, TestSize.Level1)
153 {
154 ASSERT_NE(demuxerPluginManager_, nullptr);
155 int32_t streamID = ID_TEST;
156 int32_t trackId = ID_TEST;
157 int32_t innerTrackId = ID_TEST;
158 TrackType type = TrackType::TRACK_AUDIO;
159 MediaTrackMap mediaTrackMap;
160 mediaTrackMap.streamID = ID_TEST;
161 mediaTrackMap.innerTrackIndex = INVALID_ID;
162 demuxerPluginManager_->trackInfoMap_[0] = mediaTrackMap;
163 Meta meta;
164 meta.SetData(Tag::MIME_TYPE, "audio_test");
165 demuxerPluginManager_->curMediaInfo_.tracks.push_back(meta);
166 demuxerPluginManager_->GetTrackInfoByStreamID(streamID, trackId, innerTrackId, type);
167 EXPECT_EQ(innerTrackId, INVALID_ID);
168 }
169
170 /**
171 * @tc.name : Test LoadCurrentAllPlugin API
172 * @tc.number: LoadCurrentAllPlugin_001
173 * @tc.desc : Test curAudioStreamID_ != INVALID_STREAM_OR_TRACK_ID
174 * Test curSubTitleStreamID_ != INVALID_STREAM_OR_TRACK_ID
175 */
176 HWTEST_F(DemuxerPluginManagerUnittest, LoadCurrentAllPlugin_001, TestSize.Level1)
177 {
178 ASSERT_NE(demuxerPluginManager_, nullptr);
179 auto mockStreamDemuxer = std::make_shared<MockBaseStreamDemuxer>();
180 EXPECT_CALL(*(mockStreamDemuxer), SnifferMediaType(_)).WillRepeatedly(testing::Return(""));
181 std::shared_ptr<BaseStreamDemuxer> streamDemuxer = mockStreamDemuxer;
182 Plugins::MediaInfo mediaInfo;
183 demuxerPluginManager_->curAudioStreamID_ = ID_TEST;
184 auto ret = demuxerPluginManager_->LoadCurrentAllPlugin(streamDemuxer, mediaInfo);
185 EXPECT_EQ(ret, Status::ERROR_INVALID_PARAMETER);
186 demuxerPluginManager_->curAudioStreamID_ = INVALID_ID;
187 demuxerPluginManager_->curSubTitleStreamID_ = ID_TEST;
188 ret = demuxerPluginManager_->LoadCurrentAllPlugin(streamDemuxer, mediaInfo);
189 EXPECT_EQ(ret, Status::ERROR_INVALID_PARAMETER);
190 }
191
192 /**
193 * @tc.name : Test UpdateTempTrackMapInfo API
194 * @tc.number: UpdateTempTrackMapInfo_001
195 * @tc.desc : Test newInnerTrackIndex != -1
196 */
197 HWTEST_F(DemuxerPluginManagerUnittest, UpdateTempTrackMapInfo_001, TestSize.Level1)
198 {
199 ASSERT_NE(demuxerPluginManager_, nullptr);
200 MediaTrackMap mediaTrackMap;
201 mediaTrackMap.streamID = ID_TEST;
202 demuxerPluginManager_->trackInfoMap_[0] = mediaTrackMap;
203 demuxerPluginManager_->temp2TrackInfoMap_[0] = mediaTrackMap;
204 int32_t oldTrackId = ID_TEST;
205 int32_t newTrackId = ID_TEST;
206 int32_t newInnerTrackIndex = ID_TEST;
207 demuxerPluginManager_->UpdateTempTrackMapInfo(oldTrackId, newTrackId, newInnerTrackIndex);
208 EXPECT_EQ(demuxerPluginManager_->temp2TrackInfoMap_[0].innerTrackIndex, newInnerTrackIndex);
209 }
210
211 /**
212 * @tc.name : Test GetStreamIDByTrackType API
213 * @tc.number: GetStreamIDByTrackType_001
214 * @tc.desc : Test type = TRACK_VIDEO && type == TRACK_SUBTITLE && type == INVALID_TYPE
215 */
216 HWTEST_F(DemuxerPluginManagerUnittest, GetStreamIDByTrackType_001, TestSize.Level1)
217 {
218 ASSERT_NE(demuxerPluginManager_, nullptr);
219 TrackType type = TrackType::TRACK_VIDEO;
220 auto ret = demuxerPluginManager_->GetStreamIDByTrackType(type);
221 EXPECT_EQ(ret, INVALID_ID);
222 type = TrackType::TRACK_SUBTITLE;
223 ret = demuxerPluginManager_->GetStreamIDByTrackType(type);
224 EXPECT_EQ(ret, INVALID_ID);
225 type = static_cast<TrackType>(INVALID_TYPE);
226 ret = demuxerPluginManager_->GetStreamIDByTrackType(type);
227 EXPECT_EQ(ret, INVALID_ID);
228 }
229
230 /**
231 * @tc.name : Test WaitForInitialBufferingEnd API
232 * @tc.number: WaitForInitialBufferingEnd_001
233 * @tc.desc : Test isSetSucc == false
234 */
235 HWTEST_F(DemuxerPluginManagerUnittest, WaitForInitialBufferingEnd_001, TestSize.Level1)
236 {
237 ASSERT_NE(demuxerPluginManager_, nullptr);
238 auto mockStreamDemuxer = std::make_shared<MockBaseStreamDemuxer>();
239 EXPECT_CALL(*(mockStreamDemuxer), SetSourceInitialBufferSize(_, _)).WillRepeatedly(testing::Return(false));
240 std::shared_ptr<BaseStreamDemuxer> streamDemuxer = mockStreamDemuxer;
241 int32_t offset = ID_TEST;
242 int32_t size = ID_TEST;
243 demuxerPluginManager_->WaitForInitialBufferingEnd(streamDemuxer, offset, size);
244 EXPECT_EQ(demuxerPluginManager_->isInitialBufferingSucc_.load(), true);
245 }
246
247 /**
248 * @tc.name : Test StartPlugin API
249 * @tc.number: StartPlugin_001
250 * @tc.desc : Test plugin == nullptr
251 * Test iter != streamInfoMap_.end()
252 * Test iter == streamInfoMap_.end()
253 */
254 HWTEST_F(DemuxerPluginManagerUnittest, StartPlugin_001, TestSize.Level1)
255 {
256 ASSERT_NE(demuxerPluginManager_, nullptr);
257 auto mockStreamDemuxer = std::make_shared<MockBaseStreamDemuxer>();
258 EXPECT_CALL(*(mockStreamDemuxer), SetDemuxerState(_, _)).WillRepeatedly(testing::Return());
259 EXPECT_CALL(*(mockStreamDemuxer), SnifferMediaType(_)).WillRepeatedly(testing::Return(""));
260 std::shared_ptr<BaseStreamDemuxer> streamDemuxer = mockStreamDemuxer;
261
262 MediaStreamInfo mediaInfo;
263 demuxerPluginManager_->streamInfoMap_[0] = mediaInfo;
264 int32_t streamId = ID_TEST;
265 auto ret = demuxerPluginManager_->StartPlugin(streamId, streamDemuxer);
266 EXPECT_EQ(ret, Status::ERROR_INVALID_PARAMETER);
267 EXPECT_EQ(demuxerPluginManager_->streamInfoMap_[ID_TEST].activated, true);
268 ret = demuxerPluginManager_->StartPlugin(++streamId, streamDemuxer);
269 EXPECT_EQ(ret, Status::OK);
270 }
271
272 /**
273 * @tc.name : Test StopPlugin API
274 * @tc.number: StopPlugin_001
275 * @tc.desc : Test plugin == nullptr && iter != streamInfoMap_.end()
276 */
277 HWTEST_F(DemuxerPluginManagerUnittest, StopPlugin_001, TestSize.Level1)
278 {
279 ASSERT_NE(demuxerPluginManager_, nullptr);
280 auto mockStreamDemuxer = std::make_shared<MockBaseStreamDemuxer>();
281 EXPECT_CALL(*(mockStreamDemuxer), ResetCache(_)).WillRepeatedly(testing::Return(Status::OK));
282 EXPECT_CALL(*(mockStreamDemuxer), SnifferMediaType(_)).WillRepeatedly(testing::Return(""));
283 std::shared_ptr<BaseStreamDemuxer> streamDemuxer = mockStreamDemuxer;
284
285 MediaStreamInfo mediaInfo;
286 demuxerPluginManager_->streamInfoMap_[0] = mediaInfo;
287 int32_t streamId = ID_TEST;
288 auto ret = demuxerPluginManager_->StopPlugin(streamId, streamDemuxer);
289 EXPECT_EQ(ret, Status::OK);
290 }
291
292 /**
293 * @tc.name : Test RebootPlugin API
294 * @tc.number: RebootPlugin_001
295 * @tc.desc : Test plugin == nullptr
296 * Test if (streamInfoMap_[streamId].pluginName.empty())
297 */
298 HWTEST_F(DemuxerPluginManagerUnittest, RebootPlugin_001, TestSize.Level1)
299 {
300 ASSERT_NE(demuxerPluginManager_, nullptr);
301 auto mockStreamDemuxer = std::make_shared<MockBaseStreamDemuxer>();
302 EXPECT_CALL(*(mockStreamDemuxer), ResetCache(_)).WillRepeatedly(testing::Return(Status::OK));
303 EXPECT_CALL(*(mockStreamDemuxer), SetDemuxerState(_, _)).WillRepeatedly(testing::Return());
304 EXPECT_CALL(*(mockStreamDemuxer), SnifferMediaType(_)).WillRepeatedly(testing::Return(""));
305 std::shared_ptr<BaseStreamDemuxer> streamDemuxer = mockStreamDemuxer;
306
307 MediaStreamInfo mediaInfo;
308 demuxerPluginManager_->streamInfoMap_[0] = mediaInfo;
309 int32_t streamId = ID_TEST;
310 TrackType trackType = TrackType::TRACK_VIDEO;
311 bool isRebooted = false;
312 auto ret = demuxerPluginManager_->RebootPlugin(streamId, trackType, streamDemuxer, isRebooted);
313 EXPECT_EQ(demuxerPluginManager_->streamInfoMap_[ID_TEST].activated, true);
314 EXPECT_EQ(ret, Status::ERROR_INVALID_PARAMETER);
315 }
316
317 /**
318 * @tc.name : Test GetStreamDemuxerNewStreamID API
319 * @tc.number: GetStreamDemuxerNewStreamID_001
320 * @tc.desc : Test all
321 */
322 HWTEST_F(DemuxerPluginManagerUnittest, GetStreamDemuxerNewStreamID_001, TestSize.Level1)
323 {
324 ASSERT_NE(demuxerPluginManager_, nullptr);
325 auto mockStreamDemuxer = std::make_shared<MockBaseStreamDemuxer>();
326 EXPECT_CALL(*(mockStreamDemuxer), GetNewAudioStreamID()).WillRepeatedly(testing::Return(ID_TEST));
327 EXPECT_CALL(*(mockStreamDemuxer), GetNewSubtitleStreamID()).WillRepeatedly(testing::Return(ID_TEST));
328 EXPECT_CALL(*(mockStreamDemuxer), GetNewVideoStreamID()).WillRepeatedly(testing::Return(ID_TEST));
329 std::shared_ptr<BaseStreamDemuxer> streamDemuxer = mockStreamDemuxer;
330
331 TrackType trackType = TrackType::TRACK_VIDEO;
332 auto ret = demuxerPluginManager_->GetStreamDemuxerNewStreamID(trackType, streamDemuxer);
333 EXPECT_EQ(ret, ID_TEST);
334 trackType = TrackType::TRACK_SUBTITLE;
335 ret = demuxerPluginManager_->GetStreamDemuxerNewStreamID(trackType, streamDemuxer);
336 EXPECT_EQ(ret, ID_TEST);
337 trackType = TrackType::TRACK_AUDIO;
338 ret = demuxerPluginManager_->GetStreamDemuxerNewStreamID(trackType, streamDemuxer);
339 EXPECT_EQ(ret, ID_TEST);
340 trackType = static_cast<TrackType>(INVALID_TYPE);
341 ret = demuxerPluginManager_->GetStreamDemuxerNewStreamID(trackType, streamDemuxer);
342 EXPECT_EQ(ret, INVALID_ID);
343 }
344
345 /**
346 * @tc.name : Test SingleStreamSeekTo API
347 * @tc.number: SingleStreamSeekTo_001
348 * @tc.desc : Test plugin == nullptr
349 */
350 HWTEST_F(DemuxerPluginManagerUnittest, SingleStreamSeekTo_001, TestSize.Level1)
351 {
352 ASSERT_NE(demuxerPluginManager_, nullptr);
353 int64_t seekTime = ID_TEST;
354 Plugins::SeekMode mode = Plugins::SeekMode::SEEK_NEXT_SYNC;
355 int32_t streamID = ID_TEST;
356 int64_t realSeekTime = ID_TEST;
357 auto ret = demuxerPluginManager_->SingleStreamSeekTo(seekTime, mode, streamID, realSeekTime);
358 EXPECT_EQ(ret, Status::OK);
359 }
360
361 /**
362 * @tc.name : Test Reset API
363 * @tc.number: Reset_001
364 * @tc.desc : Test return Status::OK
365 */
366 HWTEST_F(DemuxerPluginManagerUnittest, Reset_001, TestSize.Level1)
367 {
368 ASSERT_NE(demuxerPluginManager_, nullptr);
369 demuxerPluginManager_->curVideoStreamID_ = ID_TEST;
370 demuxerPluginManager_->curAudioStreamID_ = ID_TEST;
371 demuxerPluginManager_->curSubTitleStreamID_ = ID_TEST;
372 auto ret = demuxerPluginManager_->Reset();
373 EXPECT_EQ(ret, Status::OK);
374 }
375
376 /**
377 * @tc.name : Test GetCurrentBitRate API
378 * @tc.number: GetCurrentBitRate_001
379 * @tc.desc : Test return Status::OK
380 */
381 HWTEST_F(DemuxerPluginManagerUnittest, GetCurrentBitRate_001, TestSize.Level1)
382 {
383 ASSERT_NE(demuxerPluginManager_, nullptr);
384 demuxerPluginManager_->curVideoStreamID_ = ID_TEST;
385 MediaStreamInfo mediaInfo;
386 mediaInfo.bitRate = INVALID_TYPE;
387 demuxerPluginManager_->streamInfoMap_[0] = mediaInfo;
388 demuxerPluginManager_->isDash_ = true;
389 auto ret = demuxerPluginManager_->GetCurrentBitRate();
390 EXPECT_EQ(ret, INVALID_TYPE);
391 }
392 } // namespace Media
393 } // namespace OHOS
394