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 "demuxer_plugin_manager_test.h"
17
18 #include "gtest/gtest.h"
19 #include "demuxer_plugin_manager.h"
20
21 #define LOCAL true
22
23 using namespace OHOS;
24 using namespace OHOS::Media;
25 using namespace testing::ext;
26 using namespace testing;
27 using namespace std;
28
29 namespace OHOS {
30 namespace Media {
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 = 0;
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 HWTEST_F(DemuxerPluginManagerUnitTest, SetStreamID_001, TestSize.Level1)
52 {
53 // 1. Set up the test environment
54 ASSERT_NE(dataSourceImpl_, nullptr);
55
56 // 2. Call the function to be tested
57 Status status = dataSourceImpl_->SetStreamID(1);
58
59 // 3. Verify the result
60 EXPECT_EQ(status, Status::OK);
61 EXPECT_EQ(dataSourceImpl_->streamID_, 1);
62 EXPECT_EQ(dataSourceImpl_->GetStreamID(), 1);
63 }
64
65 HWTEST_F(DemuxerPluginManagerUnitTest, GetStreamCount_001, TestSize.Level1)
66 {
67 size_t streamCount = demuxerPluginManager_->GetStreamCount();
68
69 EXPECT_EQ(streamCount, demuxerPluginManager_->streamInfoMap_.size());
70 }
71
72 HWTEST_F(DemuxerPluginManagerUnitTest, LoadCurrentSubtitlePlugin_001, TestSize.Level1)
73 {
74 demuxerPluginManager_->curSubTitleStreamID_ = -1;
75 Plugins::MediaInfo mediaInfo;
76 Status status = demuxerPluginManager_->LoadCurrentSubtitlePlugin(streamDemuxer_, mediaInfo);
77
78 EXPECT_EQ(status, Status::ERROR_UNKNOWN);
79 }
80
81 HWTEST_F(DemuxerPluginManagerUnitTest, GetInnerTrackIDByTrackID_001, TestSize.Level1)
82 {
83 int32_t trackId = 1;
84 demuxerPluginManager_->trackInfoMap_[trackId].innerTrackIndex = 2;
85
86 // 2. Call the function to be tested
87 int32_t innerTrackId = demuxerPluginManager_->GetInnerTrackIDByTrackID(trackId);
88
89 // 3. Verify the result
90 EXPECT_EQ(innerTrackId, 2);
91 }
92
93 HWTEST_F(DemuxerPluginManagerUnitTest, GetInnerTrackIDByTrackID_002, TestSize.Level1)
94 {
95 int32_t trackId = 1;
96
97 // 2. Call the function to be tested
98 int32_t innerTrackId = demuxerPluginManager_->GetInnerTrackIDByTrackID(trackId);
99
100 // 3. Verify the result
101 EXPECT_EQ(innerTrackId, -1);
102 }
103
104 HWTEST_F(DemuxerPluginManagerUnitTest, AddExternalSubtitle_001, TestSize.Level1)
105 {
106 // 1. Set up the test environment
107 demuxerPluginManager_->curSubTitleStreamID_ = -1;
108 // 2. Call the function to be tested
109 int32_t result = demuxerPluginManager_->AddExternalSubtitle();
110 // 3. Verify the result
111 EXPECT_EQ(result, 0);
112 EXPECT_EQ(demuxerPluginManager_->curSubTitleStreamID_, 0);
113
114 // 1. Set up the test environment
115 demuxerPluginManager_->curSubTitleStreamID_ = 0;
116 // 2. Call the function to be tested
117 result = demuxerPluginManager_->AddExternalSubtitle();
118 }
119
120 HWTEST_F(DemuxerPluginManagerUnitTest, IsSubtitleMime_001, TestSize.Level1)
121 {
122 // 1. Set up the test environment
123 std::string mime = "application/x-subrip";
124 // 2. Call the function to be tested
125 bool result = demuxerPluginManager_->IsSubtitleMime(mime);
126 // 3. Verify the result
127 EXPECT_EQ(result, true);
128
129 // 1. Set up the test environment
130 mime = "text/vtt";
131 // 2. Call the function to be tested
132 result = demuxerPluginManager_->IsSubtitleMime(mime);
133 // 3. Verify the result
134 EXPECT_EQ(result, true);
135
136 // 1. Set up the test environment
137 mime = "video/mp4";
138 // 2. Call the function to be tested
139 result = demuxerPluginManager_->IsSubtitleMime(mime);
140 // 3. Verify the result
141 EXPECT_EQ(result, false);
142 }
143
144 HWTEST_F(DemuxerPluginManagerUnitTest, GetTrackTypeByTrackID_001, TestSize.Level1)
145 {
146 // 1. Set up the test environment
147 int32_t trackId = 0;
148 std::vector<Meta> tracks;
149 Meta meta;
150 meta.SetData(Tag::MIME_TYPE, "audio/mpeg");
151 tracks.push_back(meta);
152 Plugins::MediaInfo mediaInfo;
153 mediaInfo.tracks = tracks;
154 demuxerPluginManager_->curMediaInfo_ = mediaInfo;
155
156 // 2. Call the function to be tested
157 TrackType result = demuxerPluginManager_->GetTrackTypeByTrackID(trackId);
158
159 // 3. Verify the result
160 EXPECT_EQ(result, TRACK_AUDIO);
161 }
162
163 HWTEST_F(DemuxerPluginManagerUnitTest, GetTrackTypeByTrackID_002, TestSize.Level1)
164 {
165 // 1. Set up the test environment
166 int32_t trackId = 0;
167 std::vector<Meta> tracks;
168 Meta meta;
169 meta.SetData(Tag::MIME_TYPE, "video/mpeg");
170 tracks.push_back(meta);
171 Plugins::MediaInfo mediaInfo;
172 mediaInfo.tracks = tracks;
173 demuxerPluginManager_->curMediaInfo_ = mediaInfo;
174
175 // 2. Call the function to be tested
176 TrackType result = demuxerPluginManager_->GetTrackTypeByTrackID(trackId);
177
178 // 3. Verify the result
179 EXPECT_EQ(result, TRACK_VIDEO);
180 }
181
182 HWTEST_F(DemuxerPluginManagerUnitTest, GetTrackTypeByTrackID_003, TestSize.Level1)
183 {
184 // 1. Set up the test environment
185 int32_t trackId = 0;
186 std::vector<Meta> tracks;
187 Meta meta;
188 meta.SetData(Tag::MIME_TYPE, "application/x-subrip");
189 tracks.push_back(meta);
190 Plugins::MediaInfo mediaInfo;
191 mediaInfo.tracks = tracks;
192 demuxerPluginManager_->curMediaInfo_ = mediaInfo;
193
194 // 2. Call the function to be tested
195 TrackType result = demuxerPluginManager_->GetTrackTypeByTrackID(trackId);
196
197 // 3. Verify the result
198 EXPECT_EQ(result, TRACK_SUBTITLE);
199 }
200
201 HWTEST_F(DemuxerPluginManagerUnitTest, GetTrackTypeByTrackID_004, TestSize.Level1)
202 {
203 // 1. Set up the test environment
204 int32_t trackId = 0;
205 std::vector<Meta> tracks;
206 Meta meta;
207 meta.SetData(Tag::MIME_TYPE, "unknown/type");
208 tracks.push_back(meta);
209 Plugins::MediaInfo mediaInfo;
210 mediaInfo.tracks = tracks;
211 demuxerPluginManager_->curMediaInfo_ = mediaInfo;
212
213 // 2. Call the function to be tested
214 TrackType result = demuxerPluginManager_->GetTrackTypeByTrackID(trackId);
215
216 // 3. Verify the result
217 EXPECT_EQ(result, TRACK_INVALID);
218 }
219
220 HWTEST_F(DemuxerPluginManagerUnitTest, GetStreamTypeByTrackID_001, TestSize.Level1)
221 {
222 int32_t trackId = 1;
223 std::map<int32_t, MediaTrackMap> mediaTrackMap;
224 mediaTrackMap[1].streamID = 1;
225 demuxerPluginManager_->trackInfoMap_ = mediaTrackMap;
226 demuxerPluginManager_->streamInfoMap_[1].type = StreamType::VIDEO;
227 // 2. Call the function to be tested
228 StreamType result = demuxerPluginManager_->GetStreamTypeByTrackID(trackId);
229
230 // 3. Verify the result
231 EXPECT_EQ(result, StreamType::VIDEO);
232 }
233
234 HWTEST_F(DemuxerPluginManagerUnitTest, UpdateDefaultStreamID_001, TestSize.Level1)
235 {
236 // 1. Set up the test environment
237 Plugins::MediaInfo mediaInfo;
238 int32_t newStreamID = 1; // Assuming streamID 1 is valid
239
240 // 2. Call the function to be tested
241 Status result = demuxerPluginManager_->UpdateDefaultStreamID(mediaInfo, StreamType::AUDIO, newStreamID);
242
243 // 3. Verify the result
244 EXPECT_EQ(demuxerPluginManager_->curAudioStreamID_, newStreamID);
245 EXPECT_EQ(result, Status::OK);
246 }
247
248 HWTEST_F(DemuxerPluginManagerUnitTest, UpdateDefaultStreamID_002, TestSize.Level1)
249 {
250 // 1. Set up the test environment
251 Plugins::MediaInfo mediaInfo;
252 int32_t newStreamID = 1; // Assuming streamID 1 is valid
253
254 // 2. Call the function to be tested
255 Status result = demuxerPluginManager_->UpdateDefaultStreamID(mediaInfo, StreamType::SUBTITLE, newStreamID);
256
257 // 3. Verify the result
258 EXPECT_EQ(demuxerPluginManager_->curSubTitleStreamID_, newStreamID);
259 EXPECT_EQ(result, Status::OK);
260 }
261
262 HWTEST_F(DemuxerPluginManagerUnitTest, UpdateDefaultStreamID_003, TestSize.Level1)
263 {
264 // 1. Set up the test environment
265 Plugins::MediaInfo mediaInfo;
266 int32_t newStreamID = 1; // Assuming streamID 1 is valid
267
268 // 2. Call the function to be tested
269 Status result = demuxerPluginManager_->UpdateDefaultStreamID(mediaInfo, StreamType::VIDEO, newStreamID);
270
271 // 3. Verify the result
272 EXPECT_EQ(demuxerPluginManager_->curVideoStreamID_, newStreamID);
273 EXPECT_EQ(result, Status::OK);
274 }
275
276 HWTEST_F(DemuxerPluginManagerUnitTest, SetResetEosStatus_001, TestSize.Level1)
277 {
278 // 1. Set up the test environment
279 bool flag = true;
280
281 // 2. Call the function to be tested
282 demuxerPluginManager_->SetResetEosStatus(flag);
283
284 // 3. Verify the result
285 EXPECT_EQ(demuxerPluginManager_->needResetEosStatus_, flag);
286 }
287
288 HWTEST_F(DemuxerPluginManagerUnitTest, ReadAt_001, TestSize.Level1)
289 {
290 int64_t offset = 1;
291 std::shared_ptr<Buffer> buffer = nullptr;
292 size_t expectedLen = 0;
293 dataSourceImpl_->stream_->seekable_ = Plugins::Seekable::UNSEEKABLE;
294 dataSourceImpl_->stream_->mediaDataSize_ = 0;
295 EXPECT_CALL(*streamDemuxer_, CallbackReadAt).WillRepeatedly(Return(Status::OK));
296 EXPECT_EQ(dataSourceImpl_->ReadAt(offset, buffer, expectedLen), Status::ERROR_UNKNOWN);
297 buffer = std::shared_ptr<Buffer>();
298 EXPECT_EQ(dataSourceImpl_->ReadAt(offset, buffer, expectedLen), Status::ERROR_UNKNOWN);
299 buffer = nullptr;
300 dataSourceImpl_->stream_->seekable_ = Plugins::Seekable::SEEKABLE;
301 dataSourceImpl_->stream_->mediaDataSize_ = 0;
302 offset = 1;
303 EXPECT_EQ(dataSourceImpl_->ReadAt(offset, buffer, expectedLen), Status::ERROR_UNKNOWN);
304 }
305
306 HWTEST_F(DemuxerPluginManagerUnitTest, UpdateTempTrackMapInfo_001, TestSize.Level1)
307 {
308 int32_t oldTrackId = 0;
309 int32_t newTrackId = 0;
310 int32_t newInnerTrackIndex = 0;
311 demuxerPluginManager_->temp2TrackInfoMap_[oldTrackId] = MediaTrackMap();
312 demuxerPluginManager_->temp2TrackInfoMap_[oldTrackId].streamID = 0;
313 demuxerPluginManager_->temp2TrackInfoMap_[oldTrackId].innerTrackIndex = 0;
314 demuxerPluginManager_->temp2TrackInfoMap_[newTrackId] = MediaTrackMap();
315 demuxerPluginManager_->temp2TrackInfoMap_[newTrackId].streamID = 0;
316 demuxerPluginManager_->temp2TrackInfoMap_[newTrackId].innerTrackIndex = 0;
317 demuxerPluginManager_->UpdateTempTrackMapInfo(oldTrackId, newTrackId, newInnerTrackIndex);
318 EXPECT_EQ(demuxerPluginManager_->temp2TrackInfoMap_[oldTrackId].innerTrackIndex, newInnerTrackIndex);
319 }
320
321 HWTEST_F(DemuxerPluginManagerUnitTest, SingleStreamSeekTo_001, TestSize.Level1)
322 {
323 Plugins::SeekMode mode = Plugins::SeekMode::SEEK_NEXT_SYNC;
324 int64_t seekTime = 0;
325 int32_t streamID = 0;
326 int64_t realSeekTime = 0;
327 demuxerPluginManager_->streamInfoMap_[0] = MediaStreamInfo();
328 demuxerPluginManager_->streamInfoMap_[0].plugin = nullptr;
329 // 110
330 EXPECT_EQ(demuxerPluginManager_->SingleStreamSeekTo(seekTime, mode, streamID, realSeekTime), Status::OK);
331 // 100
332 streamID = 2;
333 EXPECT_EQ(demuxerPluginManager_->SingleStreamSeekTo(seekTime, mode, streamID, realSeekTime), Status::OK);
334 // 000
335 streamID = -1;
336 EXPECT_EQ(demuxerPluginManager_->SingleStreamSeekTo(seekTime, mode, streamID, realSeekTime), Status::OK);
337 }
338
339 HWTEST_F(DemuxerPluginManagerUnitTest, GetCurrentBitRate_001, TestSize.Level1)
340 {
341 uint32_t bitRate = 10;
342 uint32_t ret = 0;
343 demuxerPluginManager_->curVideoStreamID_ = 1;
344 demuxerPluginManager_->streamInfoMap_[demuxerPluginManager_->curVideoStreamID_] = MediaStreamInfo();
345 demuxerPluginManager_->streamInfoMap_[demuxerPluginManager_->curVideoStreamID_].bitRate = bitRate;
346 demuxerPluginManager_->isDash_ = true;
347 // 11
348 EXPECT_EQ(demuxerPluginManager_->GetCurrentBitRate(), bitRate);
349 // 10
350 demuxerPluginManager_->curVideoStreamID_ = -1;
351 EXPECT_EQ(demuxerPluginManager_->GetCurrentBitRate(), ret);
352 // 00
353 demuxerPluginManager_->isDash_ = false;
354 EXPECT_EQ(demuxerPluginManager_->GetCurrentBitRate(), ret);
355 // 01
356 demuxerPluginManager_->curVideoStreamID_ = 1;
357 EXPECT_EQ(demuxerPluginManager_->GetCurrentBitRate(), ret);
358 }
359
360 HWTEST_F(DemuxerPluginManagerUnitTest, RebootPlugin_001, TestSize.Level1)
361 {
362 int32_t streamId = 0;
363 int32_t newStreamID = 1;
364 TrackType trackType = TRACK_AUDIO;
365 bool isRebooted;
366 demuxerPluginManager_->streamInfoMap_[0] = MediaStreamInfo();
367 demuxerPluginManager_->streamInfoMap_[1] = MediaStreamInfo();
368 EXPECT_CALL(*streamDemuxer_, ResetCache).WillRepeatedly(Return(Status::OK));
369 EXPECT_CALL(*streamDemuxer_, SetDemuxerState).WillRepeatedly(Return());
370 std::string str = "";
371 EXPECT_CALL(*streamDemuxer_, SnifferMediaType).WillRepeatedly(Return(str));
372 EXPECT_CALL(*streamDemuxer_, GetNewAudioStreamID()).WillRepeatedly(Return(newStreamID));
373 EXPECT_EQ(demuxerPluginManager_->RebootPlugin(streamId, trackType, streamDemuxer_, isRebooted),
374 Status::OK);
375 streamId = 1;
376 EXPECT_EQ(demuxerPluginManager_->RebootPlugin(streamId, trackType, streamDemuxer_, isRebooted),
377 Status::ERROR_INVALID_PARAMETER);
378 trackType = TRACK_INVALID;
379 EXPECT_EQ(demuxerPluginManager_->RebootPlugin(streamId, trackType, streamDemuxer_, isRebooted),
380 Status::ERROR_INVALID_PARAMETER);
381 streamId = 0;
382 EXPECT_EQ(demuxerPluginManager_->RebootPlugin(streamId, trackType, streamDemuxer_, isRebooted),
383 Status::ERROR_INVALID_PARAMETER);
384 }
385
386 HWTEST_F(DemuxerPluginManagerUnitTest, GetStreamDemuxerNewStreamID_001, TestSize.Level1)
387 {
388 int32_t newStreamID = 1;
389 EXPECT_CALL(*streamDemuxer_, GetNewAudioStreamID()).WillRepeatedly(Return(newStreamID));
390 EXPECT_CALL(*streamDemuxer_, GetNewSubtitleStreamID()).WillRepeatedly(Return(newStreamID));
391 EXPECT_CALL(*streamDemuxer_, GetNewVideoStreamID()).WillRepeatedly(Return(newStreamID));
392 EXPECT_EQ(streamDemuxer_->GetNewAudioStreamID(), newStreamID);
393 TrackType trackType = TRACK_AUDIO;
394 EXPECT_EQ(demuxerPluginManager_->GetStreamDemuxerNewStreamID(trackType, streamDemuxer_), newStreamID);
395 trackType = TRACK_SUBTITLE;
396 EXPECT_EQ(demuxerPluginManager_->GetStreamDemuxerNewStreamID(trackType, streamDemuxer_), newStreamID);
397 trackType = TRACK_VIDEO;
398 EXPECT_EQ(demuxerPluginManager_->GetStreamDemuxerNewStreamID(trackType, streamDemuxer_), newStreamID);
399 }
400
401 HWTEST_F(DemuxerPluginManagerUnitTest, StartPlugin_001, TestSize.Level1)
402 {
403 int32_t streamId = 0;
404 EXPECT_EQ(demuxerPluginManager_->StartPlugin(streamId, streamDemuxer_), Status::OK);
405 }
406
407 HWTEST_F(DemuxerPluginManagerUnitTest, StopPlugin_001, TestSize.Level1)
408 {
409 int32_t streamId = 0;
410 EXPECT_CALL(*streamDemuxer_, ResetCache).WillRepeatedly(Return(Status::OK));
411 EXPECT_EQ(demuxerPluginManager_->StopPlugin(streamId, streamDemuxer_), Status::OK);
412 demuxerPluginManager_->streamInfoMap_[streamId] = MediaStreamInfo();
413 demuxerPluginManager_->streamInfoMap_[streamId].plugin = nullptr;
414 EXPECT_EQ(demuxerPluginManager_->StopPlugin(streamId, streamDemuxer_), Status::OK);
415 }
416
417 HWTEST_F(DemuxerPluginManagerUnitTest, GetStreamIDByTrackType_001, TestSize.Level1)
418 {
419 TrackType trackType = TRACK_VIDEO;
420 demuxerPluginManager_->curVideoStreamID_ = 1;
421 EXPECT_EQ(demuxerPluginManager_->GetStreamIDByTrackType(trackType), demuxerPluginManager_->curVideoStreamID_);
422 trackType = TRACK_AUDIO;
423 demuxerPluginManager_->curAudioStreamID_ = 2;
424 EXPECT_EQ(demuxerPluginManager_->GetStreamIDByTrackType(trackType), demuxerPluginManager_->curAudioStreamID_);
425 trackType = TRACK_SUBTITLE;
426 demuxerPluginManager_->curSubTitleStreamID_ = 3;
427 EXPECT_EQ(demuxerPluginManager_->GetStreamIDByTrackType(trackType), demuxerPluginManager_->curSubTitleStreamID_);
428 trackType = TRACK_INVALID;
429 EXPECT_EQ(demuxerPluginManager_->GetStreamIDByTrackType(trackType), -1);
430 }
431
432 }
433 }