• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 "gtest/gtest.h"
17 #include "demuxer_plugin_manager.h"
18 #include "stream_demuxer.h"
19 #include "plugin/plugin_manager_v2.h"
20 
21 using namespace OHOS;
22 using namespace OHOS::Media;
23 using namespace testing::ext;
24 using namespace testing;
25 using namespace std;
26 
27 namespace OHOS {
28 namespace Media {
29 
30 class DemuxerPluginInnerFuncTest : public testing::Test {
31 public:
32     // SetUpTestCase: Called before all test cases
33     static void SetUpTestCase(void);
34     // TearDownTestCase: Called after all test case
35     static void TearDownTestCase(void);
36     // SetUp: Called before each test cases
37     void SetUp(void);
38     // TearDown: Called after each test cases
39     void TearDown(void);
40 
41 protected:
42     std::shared_ptr<DataSourceImpl> dataSourceImpl_{ nullptr };
43 
44 private:
45     bool CreateDataSource(const std::string& filePath);
46     bool CreateDemuxerPluginByName(const std::string& typeName, const std::string& filePath, int probSize);
47     bool PluginSelectTracks();
48     bool PluginReadSample(uint32_t idx, uint32_t& flag);
49     void CountFrames(uint32_t index, uint32_t flag);
50     void SetEosValue();
51     bool isEOS(std::map<uint32_t, bool>& countFlag);
52     void RemoveValue();
53     bool ResultAssert(uint32_t frames0, uint32_t frames1, uint32_t keyFrames0, uint32_t keyFrames1);
54     bool PluginReadAllSample();
55     bool PluginSeekTo(int64_t seekTime, SeekMode mode);
56     bool CreateDemuxerPluginByNotExistName(const std::string& typeName, const std::string& filePath, int probSize);
57 
58     int streamId_ = 0;
59     std::map<uint32_t, uint32_t> frames_;
60     std::map<uint32_t, uint32_t> keyFrames_;
61     std::map<uint32_t, bool> eosFlag_;
62     std::vector<uint32_t> selectedTrackIds_;
63     std::vector<uint8_t> buffer_;
64 
65     std::shared_ptr<Media::StreamDemuxer> realStreamDemuxer_{ nullptr };
66     std::shared_ptr<Media::MediaSource> mediaSource_{ nullptr };
67     std::shared_ptr<Media::Source> realSource_{ nullptr };
68     std::shared_ptr<Media::PluginBase> pluginBase_{ nullptr };
69 };
70 
71 static const int BUFFER_PADDING_SIZE = 1024;
72 static const int DEF_PROB_SIZE = 16 * 1024;
73 constexpr int32_t THOUSAND = 1000.0;
74 
75 static const std::string DEMUXER_PLUGIN_NAME_AAC = "avdemux_aac";
76 static const std::string DEMUXER_PLUGIN_NAME_AMR = "avdemux_amr";
77 static const std::string DEMUXER_PLUGIN_NAME_APE = "avdemux_ape";
78 static const std::string DEMUXER_PLUGIN_NAME_FLAC = "avdemux_flac";
79 static const std::string DEMUXER_PLUGIN_NAME_FLV = "avdemux_flv";
80 static const std::string DEMUXER_PLUGIN_NAME_MATROSKA = "avdemux_matroska,webm";
81 static const std::string DEMUXER_PLUGIN_NAME_MOV_S = "avdemux_mov,mp4,m4a,3gp,3g2,mj2";
82 static const std::string DEMUXER_PLUGIN_NAME_MP3 = "avdemux_mp3";
83 static const std::string DEMUXER_PLUGIN_NAME_MPEG = "avdemux_mpeg";
84 static const std::string DEMUXER_PLUGIN_NAME_MPEGTS = "avdemux_mpegts";
85 static const std::string DEMUXER_PLUGIN_NAME_AVI = "avdemux_avi";
86 static const std::string DEMUXER_PLUGIN_NAME_SRT = "avdemux_srt";
87 static const std::string DEMUXER_PLUGIN_NAME_WEBVTT = "avdemux_webvtt";
88 static const std::string DEMUXER_PLUGIN_NAME_OGG = "avdemux_ogg";
89 static const std::string DEMUXER_PLUGIN_NAME_WAV = "avdemux_wav";
90 static const std::string DEMUXER_PLUGIN_NAME_ERR = "avdemux_test";
91 
92 static const string TEST_FILE_PATH = "/data/test/media/";
93 static const string TEST_FILE_URI_AAC = TEST_FILE_PATH + "audio/AAC_48000_1.aac";
94 static const string TEST_FILE_URI_AMRNB = TEST_FILE_PATH + "audio/amr_nb_8000_1.amr";
95 static const string TEST_FILE_URI_AMRWB = TEST_FILE_PATH + "audio/amr_wb_16000_1.amr";
96 static const string TEST_FILE_URI_APE = TEST_FILE_PATH + "audio/ape.ape";
97 static const string TEST_FILE_URI_FLAC = TEST_FILE_PATH + "audio/FLAC_48000_1.flac";
98 static const string TEST_FILE_URI_FLV = TEST_FILE_PATH + "avc_mp3.flv";
99 static const string TEST_FILE_URI_MATROSKA = TEST_FILE_PATH + "mkv.mkv";
100 static const string TEST_FILE_URI_MOV = TEST_FILE_PATH + "MPEG4_ASP@3_352_288_30_MP3_32K_1.mov";
101 static const string TEST_FILE_URI_MP4 = TEST_FILE_PATH + "01_video_audio.mp4";
102 static const string TEST_FILE_URI_FMP4 = TEST_FILE_PATH + "mp3_h265_fmp4.mp4";
103 static const string TEST_FILE_URI_M4A = TEST_FILE_PATH + "audio/M4A_48000_1.m4a";
104 static const string TEST_FILE_URI_MP3 = TEST_FILE_PATH + "audio/MP3_48000_1.mp3";
105 static const string TEST_FILE_URI_MPEG = TEST_FILE_PATH + "MPEG2_422p_1280_720_60_MP3_32K_1.mpg";
106 static const string TEST_FILE_URI_MPEGTS = TEST_FILE_PATH + "h264_aac_640.ts";
107 static const string TEST_FILE_URI_AVI = TEST_FILE_PATH + "long.avi";
108 static const string TEST_FILE_URI_SRT = TEST_FILE_PATH + "srt_2800.srt";
109 static const string TEST_FILE_URI_WEBVTT = TEST_FILE_PATH + "webvtt_test.vtt";
110 static const string TEST_FILE_URI_OGG = TEST_FILE_PATH + "audio/OGG_48000_1.ogg";
111 static const string TEST_FILE_URI_WAV = TEST_FILE_PATH + "audio/wav_48000_1.wav";
112 
SetUpTestCase(void)113 void DemuxerPluginInnerFuncTest::SetUpTestCase(void) {}
114 
TearDownTestCase(void)115 void DemuxerPluginInnerFuncTest::TearDownTestCase(void) {}
116 
SetUp(void)117 void DemuxerPluginInnerFuncTest::SetUp(void)
118 {
119 }
120 
TearDown(void)121 void DemuxerPluginInnerFuncTest::TearDown(void)
122 {
123     dataSourceImpl_ = nullptr;
124 }
125 
CreateDataSource(const std::string & filePath)126 bool DemuxerPluginInnerFuncTest::CreateDataSource(const std::string& filePath)
127 {
128     mediaSource_ = std::make_shared<MediaSource>(filePath);
129     realSource_ = std::make_shared<Source>();
130     realSource_->SetSource(mediaSource_);
131 
132     realStreamDemuxer_ = std::make_shared<StreamDemuxer>();
133     realStreamDemuxer_->SetSourceType(Plugins::SourceType::SOURCE_TYPE_URI);
134     realStreamDemuxer_->SetSource(realSource_);
135     realStreamDemuxer_->Init(filePath);
136 
137     realStreamDemuxer_->SetDemuxerState(streamId_, DemuxerState::DEMUXER_STATE_PARSE_HEADER);
138     dataSourceImpl_ = std::make_shared<DataSourceImpl>(realStreamDemuxer_, streamId_);
139     dataSourceImpl_->stream_ = realStreamDemuxer_;
140     realSource_->NotifyInitSuccess();
141 
142     return true;
143 }
144 
CreateDemuxerPluginByName(const std::string & typeName,const std::string & filePath,int probSize)145 bool DemuxerPluginInnerFuncTest::CreateDemuxerPluginByName(const std::string& typeName, const std::string& filePath,
146     int probSize)
147 {
148     if (!CreateDataSource(filePath)) {
149         printf("false return: CreateDataSource is fail\n");
150         return false;
151     }
152     pluginBase_ = Plugins::PluginManagerV2::Instance().CreatePluginByName(typeName);
153     if (!(pluginBase_ != nullptr)) {
154         printf("false return: pluginBase_ == nullptr\n");
155         return false;
156     }
157     auto demuxerPlugin = std::static_pointer_cast<Plugins::DemuxerPlugin>(pluginBase_);
158     if (!(demuxerPlugin->SetDataSourceWithProbSize(dataSourceImpl_, probSize) == Status::OK)) {
159         printf("false return: demuxerPlugin->SetDataSourceWithProbSize(dataSourceImpl_, probSize) != Status::OK\n");
160         return false;
161     }
162     realStreamDemuxer_->SetDemuxerState(streamId_, DemuxerState::DEMUXER_STATE_PARSE_FIRST_FRAME);
163 
164     return true;
165 }
166 
CreateDemuxerPluginByNotExistName(const std::string & typeName,const std::string & filePath,int probSize)167 bool DemuxerPluginInnerFuncTest::CreateDemuxerPluginByNotExistName(const std::string& typeName,
168     const std::string& filePath, int probSize)
169 {
170     if (!CreateDataSource(filePath)) {
171         printf("false return: CreateDataSource is fail\n");
172         return false;
173     }
174     pluginBase_ = Plugins::PluginManagerV2::Instance().CreatePluginByName(typeName);
175     if (!(pluginBase_ != nullptr)) {
176         printf("false return:" "pluginBase_ == nullptr\n");
177         return false;
178     }
179     auto demuxerPlugin = std::static_pointer_cast<Plugins::DemuxerPlugin>(pluginBase_);
180     if (!(demuxerPlugin->SetDataSourceWithProbSize(dataSourceImpl_, probSize) == Status::ERROR_INVALID_PARAMETER)) {
181         printf("false return: demuxerPlugin->SetDataSourceWithProbSize(dataSourceImpl_, probSize) !="
182             "Status::ERROR_INVALID_PARAMETER\n");
183         return false;
184     }
185     return true;
186 }
187 
PluginSelectTracks()188 bool DemuxerPluginInnerFuncTest::PluginSelectTracks()
189 {
190     MediaInfo mediaInfo;
191     auto demuxerPlugin = std::static_pointer_cast<Plugins::DemuxerPlugin>(pluginBase_);
192     if (!(demuxerPlugin->GetMediaInfo(mediaInfo) == Status::OK)) {
193         printf("false return: demuxerPlugin->GetMediaInfo(mediaInfo) != Status::OK\n");
194         return false;
195     }
196     for (auto i = 0; i < mediaInfo.tracks.size(); i++) {
197         std::string mime;
198         mediaInfo.tracks[i].GetData(Tag::MIME_TYPE, mime);
199         if (mime.find("video/") == 0 || mime.find("audio/") == 0 ||
200             mime.find("application/") == 0 || mime.find("text/vtt") == 0) {
201             if (mime.find("video/") == 0) {
202                 printf("the video track id is %d\n", i);
203             }
204             if (mime.find("audio/") == 0) {
205                 printf("the audio track id is %d\n", i);
206             }
207             demuxerPlugin->SelectTrack(static_cast<uint32_t>(i));
208             selectedTrackIds_.push_back(static_cast<uint32_t>(i));
209             frames_[i] = 0;
210             keyFrames_[i] = 0;
211             eosFlag_[i] = false;
212         }
213     }
214 
215     return true;
216 }
217 
PluginReadSample(uint32_t idx,uint32_t & flag)218 bool DemuxerPluginInnerFuncTest::PluginReadSample(uint32_t idx, uint32_t& flag)
219 {
220     int bufSize = 0;
221     auto demuxerPlugin = std::static_pointer_cast<Plugins::DemuxerPlugin>(pluginBase_);
222     demuxerPlugin->GetNextSampleSize(idx, bufSize);
223     if (bufSize > buffer_.size()) {
224         buffer_.resize(bufSize + BUFFER_PADDING_SIZE);
225     }
226 
227     auto avBuf = AVBuffer::CreateAVBuffer(buffer_.data(), bufSize, bufSize);
228     if (!(avBuf != nullptr)) {
229         printf("false return: avBuf == nullptr\n");
230         return false;
231     }
232     demuxerPlugin->ReadSample(idx, avBuf);
233     flag = avBuf->flag_;
234 
235     return true;
236 }
237 
PluginSeekTo(int64_t seekTime,SeekMode mode)238 bool DemuxerPluginInnerFuncTest::PluginSeekTo(int64_t seekTime, SeekMode mode)
239 {
240     int64_t realSeekTime = 0;
241     auto demuxerPlugin = std::static_pointer_cast<Plugins::DemuxerPlugin>(pluginBase_);
242     if (!(demuxerPlugin->SeekTo(0, seekTime / THOUSAND, mode, realSeekTime) == Status::OK)) {
243         printf("false return: demuxerPlugin->SeekTo(0, seekTime / THOUSAND, mode, realSeekTime) != Status::OK\n");
244         return false;
245     }
246     PluginReadAllSample();
247     return true;
248 }
249 
CountFrames(uint32_t index,uint32_t flag)250 void DemuxerPluginInnerFuncTest::CountFrames(uint32_t index, uint32_t flag)
251 {
252     if (flag & static_cast<uint32_t>(AVBufferFlag::EOS)) {
253         eosFlag_[index] = true;
254         return;
255     }
256 
257     if (flag & static_cast<uint32_t>(AVBufferFlag::SYNC_FRAME)) {
258         keyFrames_[index]++;
259         frames_[index]++;
260     } else if ((flag & static_cast<uint32_t>(AVBufferFlag::NONE)) == static_cast<uint32_t>(AVBufferFlag::NONE)) {
261         frames_[index]++;
262     } else {
263         SetEosValue();
264         printf("flag is unknown, read sample break");
265     }
266 }
267 
isEOS(map<uint32_t,bool> & countFlag)268 bool DemuxerPluginInnerFuncTest::isEOS(map<uint32_t, bool>& countFlag)
269 {
270     auto ret = std::find_if(countFlag.begin(), countFlag.end(), [](const pair<uint32_t, bool>& p) {
271         return p.second == false;
272     });
273 
274     return ret == countFlag.end();
275 }
276 
SetEosValue()277 void DemuxerPluginInnerFuncTest::SetEosValue()
278 {
279     std::for_each(selectedTrackIds_.begin(), selectedTrackIds_.end(), [this](uint32_t idx) {
280         eosFlag_[idx] = true;
281     });
282 }
283 
RemoveValue()284 void DemuxerPluginInnerFuncTest::RemoveValue()
285 {
286     if (!frames_.empty()) {
287         frames_.clear();
288     }
289     if (!keyFrames_.empty()) {
290         keyFrames_.clear();
291     }
292     if (!eosFlag_.empty()) {
293         eosFlag_.clear();
294     }
295 }
296 
ResultAssert(uint32_t frames0,uint32_t frames1,uint32_t keyFrames0,uint32_t keyFrames1)297 bool DemuxerPluginInnerFuncTest::ResultAssert(uint32_t frames0, uint32_t frames1, uint32_t keyFrames0,
298     uint32_t keyFrames1)
299 {
300     printf("frames_[0]=%d | kFrames[0]=%d\n", frames_[0], keyFrames_[0]);
301     printf("frames_[1]=%d | kFrames[1]=%d\n", frames_[1], keyFrames_[1]);
302     if (!(frames_[0] == frames0)) {
303         printf("false return: frames_[0] != frames0\n");
304         return false;
305     }
306     if (!(frames_[1] == frames1)) {
307         printf("false return: frames_[1] =!= frames1\n");
308         return false;
309     }
310     if (!(keyFrames_[0] == keyFrames0)) {
311         printf("false return: keyFrames_[0] != keyFrames0\n");
312         return false;
313     }
314     if (!(keyFrames_[1] == keyFrames1)) {
315         printf("false return: keyFrames_[1] != keyFrames1\n");
316         return false;
317     }
318     return true;
319 }
320 
PluginReadAllSample()321 bool DemuxerPluginInnerFuncTest::PluginReadAllSample()
322 {
323     while (!isEOS(eosFlag_)) {
324         for (auto idx : selectedTrackIds_) {
325             uint32_t flag = 0;
326             if (!PluginReadSample(idx, flag)) {
327                 printf("false return: PluginReadSample(idx, flag) is fail\n");
328                 return false;
329             }
330             CountFrames(idx, flag);
331         }
332     }
333 
334     return true;
335 }
336 
337 /**
338  * @tc.number    : DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_API_0001
339  * @tc.name      : SetDataSourceWithProbSize, const std::shared_ptr<DataSource>& source is nullptr
340  * @tc.desc      : api test
341  */
342 HWTEST_F(DemuxerPluginInnerFuncTest, DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_API_0001, TestSize.Level1)
343 {
344     pluginBase_ = Plugins::PluginManagerV2::Instance().CreatePluginByName(DEMUXER_PLUGIN_NAME_AAC);
345     ASSERT_NE(pluginBase_, nullptr);
346 
347     auto demuxerPlugin = std::static_pointer_cast<Plugins::DemuxerPlugin>(pluginBase_);
348     ASSERT_EQ(demuxerPlugin->SetDataSourceWithProbSize(nullptr, DEF_PROB_SIZE), Status::ERROR_INVALID_PARAMETER);
349 }
350 
351 /**
352  * @tc.number    : DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_API_0002
353  * @tc.name      : SetDataSourceWithProbSize, const int probSize < 0
354  * @tc.desc      : api test
355  */
356 HWTEST_F(DemuxerPluginInnerFuncTest, DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_API_0002, TestSize.Level1)
357 {
358     ASSERT_EQ(CreateDataSource(TEST_FILE_URI_AAC), true);
359     pluginBase_ = Plugins::PluginManagerV2::Instance().CreatePluginByName(DEMUXER_PLUGIN_NAME_AAC);
360     ASSERT_NE(pluginBase_, nullptr);
361 
362     auto demuxerPlugin = std::static_pointer_cast<Plugins::DemuxerPlugin>(pluginBase_);
363     ASSERT_EQ(demuxerPlugin->SetDataSourceWithProbSize(dataSourceImpl_, -1), Status::ERROR_INVALID_PARAMETER);
364 }
365 
366 /**
367  * @tc.number    : DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_API_0003
368  * @tc.name      : SetDataSourceWithProbSize, formatContext_ is nullptr
369  * @tc.desc      : api test
370  */
371 HWTEST_F(DemuxerPluginInnerFuncTest, DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_API_0003, TestSize.Level2)
372 {
373     ASSERT_EQ(CreateDataSource(TEST_FILE_URI_AAC), true);
374     pluginBase_ = Plugins::PluginManagerV2::Instance().CreatePluginByName(DEMUXER_PLUGIN_NAME_AAC);
375     ASSERT_NE(pluginBase_, nullptr);
376 
377     auto demuxerPlugin = std::static_pointer_cast<Plugins::DemuxerPlugin>(pluginBase_);
378     ASSERT_EQ(demuxerPlugin->SetDataSourceWithProbSize(dataSourceImpl_, DEF_PROB_SIZE),
379         Status::OK);
380     ASSERT_EQ(demuxerPlugin->SetDataSourceWithProbSize(dataSourceImpl_, DEF_PROB_SIZE),
381         Status::ERROR_WRONG_STATE);
382 }
383 
384 /**
385  * @tc.number    : DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_API_0004
386  * @tc.name      : CreatePluginByName, name is empty string
387  * @tc.desc      : api test
388  */
389 HWTEST_F(DemuxerPluginInnerFuncTest, DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_API_0004, TestSize.Level2)
390 {
391     pluginBase_ = Plugins::PluginManagerV2::Instance().CreatePluginByName("");
392     ASSERT_EQ(pluginBase_, nullptr);
393 }
394 
395 /**
396  * @tc.number    : DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0001
397  * @tc.name      : create plugin by avdemux_aac, container format is aac, read and seek
398  * @tc.desc      : function test
399  */
400 HWTEST_F(DemuxerPluginInnerFuncTest, DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0001, TestSize.Level2)
401 {
402     ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_AAC, TEST_FILE_URI_AAC, DEF_PROB_SIZE), true);
403     ASSERT_EQ(PluginSelectTracks(), true);
404     ASSERT_EQ(PluginReadAllSample(), true);
405     ASSERT_EQ(ResultAssert(9457, 0, 9457, 0), true);
406     RemoveValue();
407     ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_AAC, TEST_FILE_URI_AAC, DEF_PROB_SIZE), true);
408     ASSERT_EQ(PluginSelectTracks(), true);
409     ASSERT_EQ(PluginSeekTo(0, Plugins::SeekMode::SEEK_NEXT_SYNC), true);
410     ASSERT_EQ(ResultAssert(9457, 0, 9457, 0), true);
411     RemoveValue();
412 }
413 
414 /**
415  * @tc.number    : DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0002
416  * @tc.name      : create plugin by avdemux_flv, container format is flv, read and seek
417  * @tc.desc      : function test
418  */
419 HWTEST_F(DemuxerPluginInnerFuncTest, DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0002, TestSize.Level0)
420 {
421     ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_FLV, TEST_FILE_URI_FLV, DEF_PROB_SIZE), true);
422     ASSERT_EQ(PluginSelectTracks(), true);
423     ASSERT_EQ(PluginReadAllSample(), true);
424     ASSERT_EQ(ResultAssert(602, 385, 3, 385), true);
425     RemoveValue();
426     ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_FLV, TEST_FILE_URI_FLV, DEF_PROB_SIZE), true);
427     ASSERT_EQ(PluginSelectTracks(), true);
428     ASSERT_EQ(PluginSeekTo(5042000, Plugins::SeekMode::SEEK_PREVIOUS_SYNC), true);
429     ASSERT_EQ(ResultAssert(352, 225, 2, 225), true);
430     RemoveValue();
431 }
432 
433 /**
434  * @tc.number    : DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0003
435  * @tc.name      : create plugin by avdemux_matroska,webm, container format is mkv, read and seek
436  * @tc.desc      : function test
437  */
438 HWTEST_F(DemuxerPluginInnerFuncTest, DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0003, TestSize.Level0)
439 {
440     ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_MATROSKA, TEST_FILE_URI_MATROSKA, DEF_PROB_SIZE), true);
441     ASSERT_EQ(PluginSelectTracks(), true);
442     ASSERT_EQ(PluginReadAllSample(), true);
443     ASSERT_EQ(ResultAssert(600, 431, 10, 431), true);
444     RemoveValue();
445     ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_MATROSKA, TEST_FILE_URI_MATROSKA, DEF_PROB_SIZE), true);
446     ASSERT_EQ(PluginSelectTracks(), true);
447     ASSERT_EQ(PluginSeekTo(9983000, Plugins::SeekMode::SEEK_CLOSEST_SYNC), true);
448     ASSERT_EQ(ResultAssert(60, 43, 1, 43), true);
449     RemoveValue();
450 }
451 
452 /**
453  * @tc.number    : DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0004
454  * @tc.name      : create plugin by avdemux_mov,mp4,m4a,3gp,3g2,mj2, container format is mov, read and seek
455  * @tc.desc      : function test
456  */
457 HWTEST_F(DemuxerPluginInnerFuncTest, DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0004, TestSize.Level1)
458 {
459     ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_MOV_S, TEST_FILE_URI_MOV, DEF_PROB_SIZE), true);
460     ASSERT_EQ(PluginSelectTracks(), true);
461     ASSERT_EQ(PluginReadAllSample(), true);
462     ASSERT_EQ(ResultAssert(60, 57, 6, 57), true);
463     RemoveValue();
464     ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_MOV_S, TEST_FILE_URI_MOV, DEF_PROB_SIZE), true);
465     ASSERT_EQ(PluginSelectTracks(), true);
466     ASSERT_EQ(PluginSeekTo(0, Plugins::SeekMode::SEEK_NEXT_SYNC), true);
467     ASSERT_EQ(ResultAssert(60, 57, 6, 57), true);
468     RemoveValue();
469 }
470 
471 /**
472  * @tc.number    : DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0005
473  * @tc.name      : create plugin by avdemux_mov,mp4,m4a,3gp,3g2,mj2, container format is fmp4, read and seek
474  * @tc.desc      : function test
475  */
476 HWTEST_F(DemuxerPluginInnerFuncTest, DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0005, TestSize.Level1)
477 {
478     ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_MOV_S, TEST_FILE_URI_FMP4, DEF_PROB_SIZE), true);
479     ASSERT_EQ(PluginSelectTracks(), true);
480     ASSERT_EQ(PluginReadAllSample(), true);
481     ASSERT_EQ(ResultAssert(372, 468, 2, 468), true);
482     RemoveValue();
483     ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_MOV_S, TEST_FILE_URI_FMP4, DEF_PROB_SIZE), true);
484     ASSERT_EQ(PluginSelectTracks(), true);
485     ASSERT_EQ(PluginSeekTo(6166341, Plugins::SeekMode::SEEK_PREVIOUS_SYNC), true);
486     ASSERT_EQ(ResultAssert(372, 468, 2, 468), true);
487     RemoveValue();
488 }
489 
490 /**
491  * @tc.number    : DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0006
492  * @tc.name      : create plugin by avdemux_mov,mp4,m4a,3gp,3g2,mj2, container format is mp4, read and seek
493  * @tc.desc      : function test
494  */
495 HWTEST_F(DemuxerPluginInnerFuncTest, DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0006, TestSize.Level2)
496 {
497     ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_MOV_S, TEST_FILE_URI_MP4, DEF_PROB_SIZE), true);
498     ASSERT_EQ(PluginSelectTracks(), true);
499     ASSERT_EQ(PluginReadAllSample(), true);
500     ASSERT_EQ(ResultAssert(384, 250, 384, 250), true);
501     RemoveValue();
502     ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_MOV_S, TEST_FILE_URI_MP4, DEF_PROB_SIZE), true);
503     ASSERT_EQ(PluginSelectTracks(), true);
504     ASSERT_EQ(PluginSeekTo(9960000, Plugins::SeekMode::SEEK_CLOSEST_SYNC), true);
505     ASSERT_EQ(ResultAssert(2, 1, 2, 1), true);
506     RemoveValue();
507 }
508 
509 /**
510  * @tc.number    : DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0007
511  * @tc.name      : create plugin by avdemux_mov,mp4,m4a,3gp,3g2,mj2, container format is m4a, read and seek
512  * @tc.desc      : function test
513  */
514 HWTEST_F(DemuxerPluginInnerFuncTest, DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0007, TestSize.Level2)
515 {
516     ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_MOV_S, TEST_FILE_URI_M4A, DEF_PROB_SIZE), true);
517     ASSERT_EQ(PluginSelectTracks(), true);
518     ASSERT_EQ(PluginReadAllSample(), true);
519     ASSERT_EQ(ResultAssert(10293, 0, 10293, 0), true);
520     RemoveValue();
521     ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_MOV_S, TEST_FILE_URI_M4A, DEF_PROB_SIZE), true);
522     ASSERT_EQ(PluginSelectTracks(), true);
523     ASSERT_EQ(PluginSeekTo(0, Plugins::SeekMode::SEEK_NEXT_SYNC), true);
524     ASSERT_EQ(ResultAssert(10292, 0, 10292, 0), true);
525     RemoveValue();
526 }
527 
528 /**
529  * @tc.number    : DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0008
530  * @tc.name      : create plugin by avdemux_amr, container format is amr, read and seek
531  * @tc.desc      : function test
532  */
533 HWTEST_F(DemuxerPluginInnerFuncTest, DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0008, TestSize.Level2)
534 {
535     ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_AMR, TEST_FILE_URI_AMRNB, DEF_PROB_SIZE), true);
536     ASSERT_EQ(PluginSelectTracks(), true);
537     ASSERT_EQ(PluginReadAllSample(), true);
538     ASSERT_EQ(ResultAssert(1501, 0, 1501, 0), true);
539     RemoveValue();
540     ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_AMR, TEST_FILE_URI_AMRNB, DEF_PROB_SIZE), true);
541     ASSERT_EQ(PluginSelectTracks(), true);
542     ASSERT_EQ(PluginSeekTo(15000000, Plugins::SeekMode::SEEK_PREVIOUS_SYNC), true);
543     ASSERT_EQ(ResultAssert(751, 0, 751, 0), true);
544     RemoveValue();
545     ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_AMR, TEST_FILE_URI_AMRWB, DEF_PROB_SIZE), true);
546     ASSERT_EQ(PluginSelectTracks(), true);
547     ASSERT_EQ(PluginReadAllSample(), true);
548     ASSERT_EQ(ResultAssert(1500, 0, 1500, 0), true);
549     RemoveValue();
550     ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_AMR, TEST_FILE_URI_AMRWB, DEF_PROB_SIZE), true);
551     ASSERT_EQ(PluginSelectTracks(), true);
552     ASSERT_EQ(PluginSeekTo(29980000, Plugins::SeekMode::SEEK_CLOSEST_SYNC), true);
553     ASSERT_EQ(ResultAssert(1, 0, 1, 0), true);
554     RemoveValue();
555 }
556 
557 /**
558  * @tc.number    : DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0009
559  * @tc.name      : create plugin by avdemux_ape, container format is ape, read and seek
560  * @tc.desc      : function test
561  */
562 HWTEST_F(DemuxerPluginInnerFuncTest, DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0009, TestSize.Level2)
563 {
564     ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_APE, TEST_FILE_URI_APE, DEF_PROB_SIZE), true);
565     ASSERT_EQ(PluginSelectTracks(), true);
566     ASSERT_EQ(PluginReadAllSample(), true);
567     ASSERT_EQ(ResultAssert(8, 0, 8, 0), true);
568     RemoveValue();
569     ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_APE, TEST_FILE_URI_APE, DEF_PROB_SIZE), true);
570     ASSERT_EQ(PluginSelectTracks(), true);
571     ASSERT_EQ(PluginSeekTo(0, Plugins::SeekMode::SEEK_NEXT_SYNC), true);
572     ASSERT_EQ(ResultAssert(8, 0, 8, 0), true);
573     RemoveValue();
574 }
575 
576 /**
577  * @tc.number    : DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0010
578  * @tc.name      : create plugin by avdemux_flac, container format is flac, read and seek
579  * @tc.desc      : function test
580  */
581 HWTEST_F(DemuxerPluginInnerFuncTest, DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0010, TestSize.Level2)
582 {
583     ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_FLAC, TEST_FILE_URI_FLAC, DEF_PROB_SIZE), true);
584     ASSERT_EQ(PluginSelectTracks(), true);
585     ASSERT_EQ(PluginReadAllSample(), true);
586     ASSERT_EQ(ResultAssert(2288, 0, 2288, 0), true);
587     RemoveValue();
588     ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_FLAC, TEST_FILE_URI_FLAC, DEF_PROB_SIZE), true);
589     ASSERT_EQ(PluginSelectTracks(), true);
590     ASSERT_EQ(PluginSeekTo(109824000, Plugins::SeekMode::SEEK_PREVIOUS_SYNC), true);
591     ASSERT_GE(frames_[0], 1143);
592     ASSERT_LE(frames_[0], 1145);
593     ASSERT_GE(keyFrames_[0], 1143);
594     ASSERT_LE(keyFrames_[0], 1145);
595     RemoveValue();
596 }
597 
598 /**
599  * @tc.number    : DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0011
600  * @tc.name      : create plugin by avdemux_mp3, container format is mp3, read and seek
601  * @tc.desc      : function test
602  */
603 HWTEST_F(DemuxerPluginInnerFuncTest, DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0011, TestSize.Level2)
604 {
605     ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_MP3, TEST_FILE_URI_MP3, DEF_PROB_SIZE), true);
606     ASSERT_EQ(PluginSelectTracks(), true);
607     ASSERT_EQ(PluginReadAllSample(), true);
608     ASSERT_EQ(ResultAssert(9150, 0, 9150, 0), true);
609     RemoveValue();
610     ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_MP3, TEST_FILE_URI_MP3, DEF_PROB_SIZE), true);
611     ASSERT_EQ(PluginSelectTracks(), true);
612     ASSERT_EQ(PluginSeekTo(219576000, Plugins::SeekMode::SEEK_CLOSEST_SYNC), true);
613     ASSERT_EQ(ResultAssert(15, 0, 15, 0), true);
614     RemoveValue();
615 }
616 
617 /**
618  * @tc.number    : DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0012
619  * @tc.name      : create plugin by avdemux_mpeg, container format is mpg, read and seek
620  * @tc.desc      : function test
621  */
622 HWTEST_F(DemuxerPluginInnerFuncTest, DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0012, TestSize.Level2)
623 {
624     ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_MPEG, TEST_FILE_URI_MPEG, DEF_PROB_SIZE), true);
625     ASSERT_EQ(PluginSelectTracks(), true);
626     ASSERT_EQ(PluginReadAllSample(), true);
627     ASSERT_EQ(ResultAssert(119, 57, 12, 57), true);
628     RemoveValue();
629     ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_MPEG, TEST_FILE_URI_MPEG, DEF_PROB_SIZE), true);
630     ASSERT_EQ(PluginSelectTracks(), true);
631     ASSERT_EQ(PluginSeekTo(0, Plugins::SeekMode::SEEK_NEXT_SYNC), true);
632     ASSERT_EQ(ResultAssert(118, 47, 11, 47), true);
633     RemoveValue();
634 }
635 
636 /**
637  * @tc.number    : DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0013
638  * @tc.name      : create plugin by avdemux_mpegts, container format is ts, read and seek
639  * @tc.desc      : function test
640  */
641 HWTEST_F(DemuxerPluginInnerFuncTest, DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0013, TestSize.Level2)
642 {
643     ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_MPEGTS, TEST_FILE_URI_MPEGTS, DEF_PROB_SIZE), true);
644     ASSERT_EQ(PluginSelectTracks(), true);
645     ASSERT_EQ(PluginReadAllSample(), true);
646     ASSERT_EQ(ResultAssert(123, 176, 1, 176), true);
647     RemoveValue();
648     ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_MPEGTS, TEST_FILE_URI_MPEGTS, DEF_PROB_SIZE), true);
649     ASSERT_EQ(PluginSelectTracks(), true);
650     ASSERT_EQ(PluginSeekTo(3500000, Plugins::SeekMode::SEEK_PREVIOUS_SYNC), true);
651     ASSERT_EQ(ResultAssert(16, 29, 0, 29), true);
652     RemoveValue();
653 }
654 
655 /**
656  * @tc.number    : DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0014
657  * @tc.name      : create plugin by avdemux_avi, container format is avi, read and seek
658  * @tc.desc      : function test
659  */
660 HWTEST_F(DemuxerPluginInnerFuncTest, DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0014, TestSize.Level2)
661 {
662     ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_AVI, TEST_FILE_URI_AVI, DEF_PROB_SIZE), true);
663     ASSERT_EQ(PluginSelectTracks(), true);
664     ASSERT_EQ(PluginReadAllSample(), true);
665     ASSERT_EQ(ResultAssert(3, 9, 1, 9), true);
666     RemoveValue();
667     ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_AVI, TEST_FILE_URI_AVI, DEF_PROB_SIZE), true);
668     ASSERT_EQ(PluginSelectTracks(), true);
669     ASSERT_EQ(PluginSeekTo(200000, Plugins::SeekMode::SEEK_CLOSEST_SYNC), true);
670     ASSERT_EQ(ResultAssert(3, 9, 1, 9), true);
671     RemoveValue();
672 }
673 
674 /**
675  * @tc.number    : DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0015
676  * @tc.name      : create plugin by avdemux_ogg, container format is ogg, read and seek
677  * @tc.desc      : function test
678  */
679 HWTEST_F(DemuxerPluginInnerFuncTest, DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0015, TestSize.Level2)
680 {
681     ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_OGG, TEST_FILE_URI_OGG, DEF_PROB_SIZE), true);
682     ASSERT_EQ(PluginSelectTracks(), true);
683     ASSERT_EQ(PluginReadAllSample(), true);
684     ASSERT_EQ(ResultAssert(11439, 0, 11439, 0), true);
685     RemoveValue();
686     ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_OGG, TEST_FILE_URI_OGG, DEF_PROB_SIZE), true);
687     ASSERT_EQ(PluginSelectTracks(), true);
688     ASSERT_EQ(PluginSeekTo(0, Plugins::SeekMode::SEEK_NEXT_SYNC), true);
689     ASSERT_EQ(ResultAssert(11439, 0, 11439, 0), true);
690     RemoveValue();
691 }
692 
693 /**
694  * @tc.number    : DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0016
695  * @tc.name      : create plugin by avdemux_wav, container format is wav, read and seek
696  * @tc.desc      : function test
697  */
698 HWTEST_F(DemuxerPluginInnerFuncTest, DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0016, TestSize.Level2)
699 {
700     ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_WAV, TEST_FILE_URI_WAV, DEF_PROB_SIZE), true);
701     ASSERT_EQ(PluginSelectTracks(), true);
702     ASSERT_EQ(PluginReadAllSample(), true);
703     ASSERT_EQ(ResultAssert(5146, 0, 5146, 0), true);
704     RemoveValue();
705     ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_WAV, TEST_FILE_URI_WAV, DEF_PROB_SIZE), true);
706     ASSERT_EQ(PluginSelectTracks(), true);
707     ASSERT_EQ(PluginSeekTo(109781333, Plugins::SeekMode::SEEK_PREVIOUS_SYNC), true);
708     ASSERT_EQ(ResultAssert(2573, 0, 2573, 0), true);
709     RemoveValue();
710 }
711 
712 /**
713  * @tc.number    : DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0017
714  * @tc.name      : create plugin by avdemux_srt, container format is srt, read and seek
715  * @tc.desc      : function test
716  */
717 HWTEST_F(DemuxerPluginInnerFuncTest, DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0017, TestSize.Level2)
718 {
719     ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_SRT, TEST_FILE_URI_SRT, DEF_PROB_SIZE), true);
720     ASSERT_EQ(PluginSelectTracks(), true);
721     ASSERT_EQ(PluginReadAllSample(), true);
722     ASSERT_EQ(ResultAssert(10, 0, 10, 0), true);
723     RemoveValue();
724     ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_SRT, TEST_FILE_URI_SRT, DEF_PROB_SIZE), true);
725     ASSERT_EQ(PluginSelectTracks(), true);
726     ASSERT_EQ(PluginSeekTo(31900000, Plugins::SeekMode::SEEK_CLOSEST_SYNC), true);
727     ASSERT_EQ(ResultAssert(1, 0, 1, 0), true);
728     RemoveValue();
729 }
730 
731 /**
732  * @tc.number    : DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0018
733  * @tc.name      : create plugin by avdemux_webvtt, container format is vtt, read and seek
734  * @tc.desc      : function test
735  */
736 HWTEST_F(DemuxerPluginInnerFuncTest, DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0018, TestSize.Level2)
737 {
738     ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_WEBVTT, TEST_FILE_URI_WEBVTT, DEF_PROB_SIZE), true);
739     ASSERT_EQ(PluginSelectTracks(), true);
740     ASSERT_EQ(PluginReadAllSample(), true);
741     ASSERT_EQ(ResultAssert(8, 0, 8, 0), true);
742     RemoveValue();
743     ASSERT_EQ(CreateDemuxerPluginByName(DEMUXER_PLUGIN_NAME_WEBVTT, TEST_FILE_URI_WEBVTT, DEF_PROB_SIZE), true);
744     ASSERT_EQ(PluginSelectTracks(), true);
745     ASSERT_EQ(PluginSeekTo(0, Plugins::SeekMode::SEEK_NEXT_SYNC), true);
746     ASSERT_EQ(ResultAssert(8, 0, 8, 0), true);
747     RemoveValue();
748 }
749 
750 /**
751  * @tc.number    : DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0019
752  * @tc.name      : create plugin by not exist name
753  * @tc.desc      : function test
754  */
755 HWTEST_F(DemuxerPluginInnerFuncTest, DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0019, TestSize.Level2)
756 {
757     pluginBase_ = Plugins::PluginManagerV2::Instance().CreatePluginByName(DEMUXER_PLUGIN_NAME_ERR);
758     ASSERT_EQ(pluginBase_, nullptr);
759 }
760 
761 /**
762  * @tc.number    : DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0020
763  * @tc.name      : create plugin by avdemux_aac, container format is not aac
764  * @tc.desc      : function test
765  */
766 HWTEST_F(DemuxerPluginInnerFuncTest, DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0020, TestSize.Level2)
767 {
768     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_AAC, TEST_FILE_URI_AMRNB, DEF_PROB_SIZE), true);
769     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_AAC, TEST_FILE_URI_AMRWB, DEF_PROB_SIZE), true);
770     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_AAC, TEST_FILE_URI_APE, DEF_PROB_SIZE), true);
771     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_AAC, TEST_FILE_URI_FLAC, DEF_PROB_SIZE), true);
772     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_AAC, TEST_FILE_URI_FLV, DEF_PROB_SIZE), true);
773     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_AAC, TEST_FILE_URI_MATROSKA, DEF_PROB_SIZE), true);
774     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_AAC, TEST_FILE_URI_MOV, DEF_PROB_SIZE), true);
775     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_AAC, TEST_FILE_URI_MP4, DEF_PROB_SIZE), true);
776     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_AAC, TEST_FILE_URI_FMP4, DEF_PROB_SIZE), true);
777     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_AAC, TEST_FILE_URI_M4A, DEF_PROB_SIZE), true);
778     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_AAC, TEST_FILE_URI_MP3, DEF_PROB_SIZE), true);
779     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_AAC, TEST_FILE_URI_MPEG, DEF_PROB_SIZE), true);
780     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_AAC, TEST_FILE_URI_MPEGTS, DEF_PROB_SIZE), true);
781     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_AAC, TEST_FILE_URI_AVI, DEF_PROB_SIZE), true);
782     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_AAC, TEST_FILE_URI_SRT, DEF_PROB_SIZE), true);
783     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_AAC, TEST_FILE_URI_WEBVTT, DEF_PROB_SIZE), true);
784     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_AAC, TEST_FILE_URI_OGG, DEF_PROB_SIZE), true);
785     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_AAC, TEST_FILE_URI_WAV, DEF_PROB_SIZE), true);
786 }
787 
788 /**
789  * @tc.number    : DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0021
790  * @tc.name      : create plugin by avdemux_amr, container format is not amr
791  * @tc.desc      : function test
792  */
793 HWTEST_F(DemuxerPluginInnerFuncTest, DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0021, TestSize.Level2)
794 {
795     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_AMR, TEST_FILE_URI_AAC, DEF_PROB_SIZE), true);
796     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_AMR, TEST_FILE_URI_APE, DEF_PROB_SIZE), true);
797     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_AMR, TEST_FILE_URI_FLAC, DEF_PROB_SIZE), true);
798     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_AMR, TEST_FILE_URI_FLV, DEF_PROB_SIZE), true);
799     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_AMR, TEST_FILE_URI_MATROSKA, DEF_PROB_SIZE), true);
800     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_AMR, TEST_FILE_URI_MOV, DEF_PROB_SIZE), true);
801     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_AMR, TEST_FILE_URI_MP4, DEF_PROB_SIZE), true);
802     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_AMR, TEST_FILE_URI_FMP4, DEF_PROB_SIZE), true);
803     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_AMR, TEST_FILE_URI_M4A, DEF_PROB_SIZE), true);
804     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_AMR, TEST_FILE_URI_MP3, DEF_PROB_SIZE), true);
805     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_AMR, TEST_FILE_URI_MPEG, DEF_PROB_SIZE), true);
806     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_AMR, TEST_FILE_URI_MPEGTS, DEF_PROB_SIZE), true);
807     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_AMR, TEST_FILE_URI_AVI, DEF_PROB_SIZE), true);
808     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_AMR, TEST_FILE_URI_SRT, DEF_PROB_SIZE), true);
809     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_AMR, TEST_FILE_URI_WEBVTT, DEF_PROB_SIZE), true);
810     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_AMR, TEST_FILE_URI_OGG, DEF_PROB_SIZE), true);
811     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_AMR, TEST_FILE_URI_WAV, DEF_PROB_SIZE), true);
812 }
813 
814 /**
815  * @tc.number    : DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0022
816  * @tc.name      : create plugin by avdemux_ape, container format is not ape
817  * @tc.desc      : function test
818  */
819 HWTEST_F(DemuxerPluginInnerFuncTest, DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0022, TestSize.Level2)
820 {
821     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_APE, TEST_FILE_URI_AAC, DEF_PROB_SIZE), true);
822     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_APE, TEST_FILE_URI_AMRNB, DEF_PROB_SIZE), true);
823     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_APE, TEST_FILE_URI_AMRWB, DEF_PROB_SIZE), true);
824     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_APE, TEST_FILE_URI_FLAC, DEF_PROB_SIZE), true);
825     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_APE, TEST_FILE_URI_FLV, DEF_PROB_SIZE), true);
826     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_APE, TEST_FILE_URI_MATROSKA, DEF_PROB_SIZE), true);
827     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_APE, TEST_FILE_URI_MOV, DEF_PROB_SIZE), true);
828     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_APE, TEST_FILE_URI_MP4, DEF_PROB_SIZE), true);
829     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_APE, TEST_FILE_URI_FMP4, DEF_PROB_SIZE), true);
830     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_APE, TEST_FILE_URI_M4A, DEF_PROB_SIZE), true);
831     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_APE, TEST_FILE_URI_MP3, DEF_PROB_SIZE), true);
832     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_APE, TEST_FILE_URI_MPEG, DEF_PROB_SIZE), true);
833     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_APE, TEST_FILE_URI_MPEGTS, DEF_PROB_SIZE), true);
834     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_APE, TEST_FILE_URI_AVI, DEF_PROB_SIZE), true);
835     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_APE, TEST_FILE_URI_SRT, DEF_PROB_SIZE), true);
836     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_APE, TEST_FILE_URI_WEBVTT, DEF_PROB_SIZE), true);
837     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_APE, TEST_FILE_URI_OGG, DEF_PROB_SIZE), true);
838     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_APE, TEST_FILE_URI_WAV, DEF_PROB_SIZE), true);
839 }
840 
841 /**
842  * @tc.number    : DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0023
843  * @tc.name      : create plugin by avdemux_flac, container format is not flac
844  * @tc.desc      : function test
845  */
846 HWTEST_F(DemuxerPluginInnerFuncTest, DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0023, TestSize.Level2)
847 {
848     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_FLAC, TEST_FILE_URI_AAC, DEF_PROB_SIZE), true);
849     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_FLAC, TEST_FILE_URI_AMRNB, DEF_PROB_SIZE), true);
850     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_FLAC, TEST_FILE_URI_AMRWB, DEF_PROB_SIZE), true);
851     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_FLAC, TEST_FILE_URI_APE, DEF_PROB_SIZE), true);
852     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_FLAC, TEST_FILE_URI_FLV, DEF_PROB_SIZE), true);
853     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_FLAC, TEST_FILE_URI_MATROSKA, DEF_PROB_SIZE), true);
854     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_FLAC, TEST_FILE_URI_MOV, DEF_PROB_SIZE), true);
855     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_FLAC, TEST_FILE_URI_MP4, DEF_PROB_SIZE), true);
856     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_FLAC, TEST_FILE_URI_FMP4, DEF_PROB_SIZE), true);
857     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_FLAC, TEST_FILE_URI_M4A, DEF_PROB_SIZE), true);
858     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_FLAC, TEST_FILE_URI_MP3, DEF_PROB_SIZE), true);
859     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_FLAC, TEST_FILE_URI_MPEG, DEF_PROB_SIZE), true);
860     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_FLAC, TEST_FILE_URI_MPEGTS, DEF_PROB_SIZE), true);
861     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_FLAC, TEST_FILE_URI_AVI, DEF_PROB_SIZE), true);
862     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_FLAC, TEST_FILE_URI_SRT, DEF_PROB_SIZE), true);
863     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_FLAC, TEST_FILE_URI_WEBVTT, DEF_PROB_SIZE), true);
864     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_FLAC, TEST_FILE_URI_OGG, DEF_PROB_SIZE), true);
865     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_FLAC, TEST_FILE_URI_WAV, DEF_PROB_SIZE), true);
866 }
867 
868 /**
869  * @tc.number    : DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0024
870  * @tc.name      : create plugin by avdemux_matroska,webm, container format is not mkv
871  * @tc.desc      : function test
872  */
873 HWTEST_F(DemuxerPluginInnerFuncTest, DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0024, TestSize.Level2)
874 {
875     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MATROSKA, TEST_FILE_URI_AAC, DEF_PROB_SIZE), true);
876     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MATROSKA, TEST_FILE_URI_AMRNB, DEF_PROB_SIZE),
877         true);
878     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MATROSKA, TEST_FILE_URI_AMRWB, DEF_PROB_SIZE),
879         true);
880     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MATROSKA, TEST_FILE_URI_APE, DEF_PROB_SIZE), true);
881     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MATROSKA, TEST_FILE_URI_FLV, DEF_PROB_SIZE), true);
882     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MATROSKA, TEST_FILE_URI_FLAC, DEF_PROB_SIZE), true);
883     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MATROSKA, TEST_FILE_URI_MOV, DEF_PROB_SIZE), true);
884     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MATROSKA, TEST_FILE_URI_MP4, DEF_PROB_SIZE), true);
885     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MATROSKA, TEST_FILE_URI_FMP4, DEF_PROB_SIZE), true);
886     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MATROSKA, TEST_FILE_URI_M4A, DEF_PROB_SIZE), true);
887     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MATROSKA, TEST_FILE_URI_MP3, DEF_PROB_SIZE), true);
888     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MATROSKA, TEST_FILE_URI_MPEG, DEF_PROB_SIZE), true);
889     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MATROSKA, TEST_FILE_URI_MPEGTS, DEF_PROB_SIZE),
890         true);
891     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MATROSKA, TEST_FILE_URI_AVI, DEF_PROB_SIZE), true);
892     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MATROSKA, TEST_FILE_URI_SRT, DEF_PROB_SIZE), true);
893     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MATROSKA, TEST_FILE_URI_WEBVTT, DEF_PROB_SIZE),
894         true);
895     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MATROSKA, TEST_FILE_URI_OGG, DEF_PROB_SIZE), true);
896     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MATROSKA, TEST_FILE_URI_WAV, DEF_PROB_SIZE), true);
897 }
898 
899 /**
900  * @tc.number    : DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0025
901  * @tc.name      : create plugin by avdemux_mov,mp4,m4a,3gp,3g2,mj2, container format is not mov/fmp4/mp4/m4a
902  * @tc.desc      : function test
903  */
904 HWTEST_F(DemuxerPluginInnerFuncTest, DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0025, TestSize.Level2)
905 {
906     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MOV_S, TEST_FILE_URI_AAC, DEF_PROB_SIZE), true);
907     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MOV_S, TEST_FILE_URI_AMRNB, DEF_PROB_SIZE), true);
908     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MOV_S, TEST_FILE_URI_AMRWB, DEF_PROB_SIZE), true);
909     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MOV_S, TEST_FILE_URI_APE, DEF_PROB_SIZE), true);
910     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MOV_S, TEST_FILE_URI_FLV, DEF_PROB_SIZE), true);
911     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MOV_S, TEST_FILE_URI_FLAC, DEF_PROB_SIZE), true);
912     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MOV_S, TEST_FILE_URI_MATROSKA, DEF_PROB_SIZE),
913         true);
914     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MOV_S, TEST_FILE_URI_MP3, DEF_PROB_SIZE), true);
915     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MOV_S, TEST_FILE_URI_MPEG, DEF_PROB_SIZE), true);
916     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MOV_S, TEST_FILE_URI_MPEGTS, DEF_PROB_SIZE), true);
917     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MOV_S, TEST_FILE_URI_AVI, DEF_PROB_SIZE), true);
918     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MOV_S, TEST_FILE_URI_SRT, DEF_PROB_SIZE), true);
919     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MOV_S, TEST_FILE_URI_WEBVTT, DEF_PROB_SIZE), true);
920     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MOV_S, TEST_FILE_URI_OGG, DEF_PROB_SIZE), true);
921     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MOV_S, TEST_FILE_URI_WAV, DEF_PROB_SIZE), true);
922 }
923 
924 /**
925  * @tc.number    : DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0026
926  * @tc.name      : create plugin by avdemux_mp3, container format is not mp3
927  * @tc.desc      : function test
928  */
929 HWTEST_F(DemuxerPluginInnerFuncTest, DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0026, TestSize.Level2)
930 {
931     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MP3, TEST_FILE_URI_AAC, DEF_PROB_SIZE), true);
932     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MP3, TEST_FILE_URI_AMRNB, DEF_PROB_SIZE), true);
933     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MP3, TEST_FILE_URI_AMRWB, DEF_PROB_SIZE), true);
934     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MP3, TEST_FILE_URI_APE, DEF_PROB_SIZE), true);
935     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MP3, TEST_FILE_URI_FLV, DEF_PROB_SIZE), true);
936     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MP3, TEST_FILE_URI_FLAC, DEF_PROB_SIZE), true);
937     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MP3, TEST_FILE_URI_MOV, DEF_PROB_SIZE), true);
938     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MP3, TEST_FILE_URI_MP4, DEF_PROB_SIZE), true);
939     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MP3, TEST_FILE_URI_FMP4, DEF_PROB_SIZE), true);
940     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MP3, TEST_FILE_URI_M4A, DEF_PROB_SIZE), true);
941     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MP3, TEST_FILE_URI_MATROSKA, DEF_PROB_SIZE), true);
942     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MP3, TEST_FILE_URI_MPEG, DEF_PROB_SIZE), true);
943     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MP3, TEST_FILE_URI_MPEGTS, DEF_PROB_SIZE), true);
944     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MP3, TEST_FILE_URI_AVI, DEF_PROB_SIZE), true);
945     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MP3, TEST_FILE_URI_SRT, DEF_PROB_SIZE), true);
946     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MP3, TEST_FILE_URI_WEBVTT, DEF_PROB_SIZE), true);
947     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MP3, TEST_FILE_URI_OGG, DEF_PROB_SIZE), true);
948     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MP3, TEST_FILE_URI_WAV, DEF_PROB_SIZE), true);
949 }
950 
951 /**
952  * @tc.number    : DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0027
953  * @tc.name      : create plugin by avdemux_mpeg, container format is not mpg
954  * @tc.desc      : function test
955  */
956 HWTEST_F(DemuxerPluginInnerFuncTest, DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0027, TestSize.Level2)
957 {
958     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MPEG, TEST_FILE_URI_AAC, DEF_PROB_SIZE), true);
959     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MPEG, TEST_FILE_URI_AMRNB, DEF_PROB_SIZE), true);
960     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MPEG, TEST_FILE_URI_AMRWB, DEF_PROB_SIZE), true);
961     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MPEG, TEST_FILE_URI_APE, DEF_PROB_SIZE), true);
962     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MPEG, TEST_FILE_URI_FLV, DEF_PROB_SIZE), true);
963     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MPEG, TEST_FILE_URI_FLAC, DEF_PROB_SIZE), true);
964     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MPEG, TEST_FILE_URI_MOV, DEF_PROB_SIZE), true);
965     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MPEG, TEST_FILE_URI_MP4, DEF_PROB_SIZE), true);
966     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MPEG, TEST_FILE_URI_FMP4, DEF_PROB_SIZE), true);
967     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MPEG, TEST_FILE_URI_M4A, DEF_PROB_SIZE), true);
968     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MPEG, TEST_FILE_URI_MATROSKA, DEF_PROB_SIZE), true);
969     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MPEG, TEST_FILE_URI_MP3, DEF_PROB_SIZE), true);
970     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MPEG, TEST_FILE_URI_MPEGTS, DEF_PROB_SIZE), true);
971     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MPEG, TEST_FILE_URI_AVI, DEF_PROB_SIZE), true);
972     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MPEG, TEST_FILE_URI_SRT, DEF_PROB_SIZE), true);
973     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MPEG, TEST_FILE_URI_WEBVTT, DEF_PROB_SIZE), true);
974     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MPEG, TEST_FILE_URI_OGG, DEF_PROB_SIZE), true);
975     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MPEG, TEST_FILE_URI_WAV, DEF_PROB_SIZE), true);
976 }
977 
978 /**
979  * @tc.number    : DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0028
980  * @tc.name      : create plugin by avdemux_mpegts, container format is not ts
981  * @tc.desc      : function test
982  */
983 HWTEST_F(DemuxerPluginInnerFuncTest, DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0028, TestSize.Level2)
984 {
985     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MPEGTS, TEST_FILE_URI_AAC, DEF_PROB_SIZE), true);
986     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MPEGTS, TEST_FILE_URI_AMRNB, DEF_PROB_SIZE), true);
987     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MPEGTS, TEST_FILE_URI_AMRWB, DEF_PROB_SIZE), true);
988     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MPEGTS, TEST_FILE_URI_APE, DEF_PROB_SIZE), true);
989     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MPEGTS, TEST_FILE_URI_FLV, DEF_PROB_SIZE), true);
990     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MPEGTS, TEST_FILE_URI_FLAC, DEF_PROB_SIZE), true);
991     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MPEGTS, TEST_FILE_URI_MOV, DEF_PROB_SIZE), true);
992     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MPEGTS, TEST_FILE_URI_MP4, DEF_PROB_SIZE), true);
993     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MPEGTS, TEST_FILE_URI_FMP4, DEF_PROB_SIZE), true);
994     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MPEGTS, TEST_FILE_URI_M4A, DEF_PROB_SIZE), true);
995     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MPEGTS, TEST_FILE_URI_MATROSKA, DEF_PROB_SIZE),
996         true);
997     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MPEGTS, TEST_FILE_URI_MP3, DEF_PROB_SIZE), true);
998     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MPEGTS, TEST_FILE_URI_MPEG, DEF_PROB_SIZE), true);
999     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MPEGTS, TEST_FILE_URI_AVI, DEF_PROB_SIZE), true);
1000     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MPEGTS, TEST_FILE_URI_SRT, DEF_PROB_SIZE), true);
1001     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MPEGTS, TEST_FILE_URI_WEBVTT, DEF_PROB_SIZE), true);
1002     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MPEGTS, TEST_FILE_URI_OGG, DEF_PROB_SIZE), true);
1003     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_MPEGTS, TEST_FILE_URI_WAV, DEF_PROB_SIZE), true);
1004 }
1005 
1006 /**
1007  * @tc.number    : DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0029
1008  * @tc.name      : create plugin by avdemux_avi, container format is not avi
1009  * @tc.desc      : function test
1010  */
1011 HWTEST_F(DemuxerPluginInnerFuncTest, DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0029, TestSize.Level2)
1012 {
1013     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_AVI, TEST_FILE_URI_AAC, DEF_PROB_SIZE), true);
1014     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_AVI, TEST_FILE_URI_AMRNB, DEF_PROB_SIZE), true);
1015     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_AVI, TEST_FILE_URI_AMRWB, DEF_PROB_SIZE), true);
1016     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_AVI, TEST_FILE_URI_APE, DEF_PROB_SIZE), true);
1017     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_AVI, TEST_FILE_URI_FLV, DEF_PROB_SIZE), true);
1018     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_AVI, TEST_FILE_URI_FLAC, DEF_PROB_SIZE), true);
1019     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_AVI, TEST_FILE_URI_MOV, DEF_PROB_SIZE), true);
1020     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_AVI, TEST_FILE_URI_MP4, DEF_PROB_SIZE), true);
1021     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_AVI, TEST_FILE_URI_FMP4, DEF_PROB_SIZE), true);
1022     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_AVI, TEST_FILE_URI_M4A, DEF_PROB_SIZE), true);
1023     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_AVI, TEST_FILE_URI_MATROSKA, DEF_PROB_SIZE), true);
1024     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_AVI, TEST_FILE_URI_MP3, DEF_PROB_SIZE), true);
1025     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_AVI, TEST_FILE_URI_MPEG, DEF_PROB_SIZE), true);
1026     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_AVI, TEST_FILE_URI_MPEGTS, DEF_PROB_SIZE), true);
1027     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_AVI, TEST_FILE_URI_SRT, DEF_PROB_SIZE), true);
1028     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_AVI, TEST_FILE_URI_WEBVTT, DEF_PROB_SIZE), true);
1029     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_AVI, TEST_FILE_URI_OGG, DEF_PROB_SIZE), true);
1030     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_AVI, TEST_FILE_URI_WAV, DEF_PROB_SIZE), true);
1031 }
1032 
1033 /**
1034  * @tc.number    : DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0030
1035  * @tc.name      : create plugin by avdemux_srt, container format is not srt
1036  * @tc.desc      : function test
1037  */
1038 HWTEST_F(DemuxerPluginInnerFuncTest, DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0030, TestSize.Level2)
1039 {
1040     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_SRT, TEST_FILE_URI_AAC, DEF_PROB_SIZE), true);
1041     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_SRT, TEST_FILE_URI_AMRNB, DEF_PROB_SIZE), true);
1042     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_SRT, TEST_FILE_URI_AMRWB, DEF_PROB_SIZE), true);
1043     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_SRT, TEST_FILE_URI_APE, DEF_PROB_SIZE), true);
1044     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_SRT, TEST_FILE_URI_FLV, DEF_PROB_SIZE), true);
1045     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_SRT, TEST_FILE_URI_FLAC, DEF_PROB_SIZE), true);
1046     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_SRT, TEST_FILE_URI_MOV, DEF_PROB_SIZE), true);
1047     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_SRT, TEST_FILE_URI_MP4, DEF_PROB_SIZE), true);
1048     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_SRT, TEST_FILE_URI_FMP4, DEF_PROB_SIZE), true);
1049     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_SRT, TEST_FILE_URI_M4A, DEF_PROB_SIZE), true);
1050     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_SRT, TEST_FILE_URI_MATROSKA, DEF_PROB_SIZE), true);
1051     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_SRT, TEST_FILE_URI_MP3, DEF_PROB_SIZE), true);
1052     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_SRT, TEST_FILE_URI_MPEG, DEF_PROB_SIZE), true);
1053     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_SRT, TEST_FILE_URI_MPEGTS, DEF_PROB_SIZE), true);
1054     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_SRT, TEST_FILE_URI_AVI, DEF_PROB_SIZE), true);
1055     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_SRT, TEST_FILE_URI_WEBVTT, DEF_PROB_SIZE), true);
1056     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_SRT, TEST_FILE_URI_OGG, DEF_PROB_SIZE), true);
1057     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_SRT, TEST_FILE_URI_WAV, DEF_PROB_SIZE), true);
1058 }
1059 
1060 /**
1061  * @tc.number    : DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0031
1062  * @tc.name      : create plugin by avdemux_webvtt, container format is not vtt
1063  * @tc.desc      : function test
1064  */
1065 HWTEST_F(DemuxerPluginInnerFuncTest, DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0031, TestSize.Level2)
1066 {
1067     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_WEBVTT, TEST_FILE_URI_AAC, DEF_PROB_SIZE), true);
1068     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_WEBVTT, TEST_FILE_URI_AMRNB, DEF_PROB_SIZE), true);
1069     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_WEBVTT, TEST_FILE_URI_AMRWB, DEF_PROB_SIZE), true);
1070     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_WEBVTT, TEST_FILE_URI_APE, DEF_PROB_SIZE), true);
1071     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_WEBVTT, TEST_FILE_URI_FLV, DEF_PROB_SIZE), true);
1072     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_WEBVTT, TEST_FILE_URI_FLAC, DEF_PROB_SIZE), true);
1073     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_WEBVTT, TEST_FILE_URI_MOV, DEF_PROB_SIZE), true);
1074     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_WEBVTT, TEST_FILE_URI_MP4, DEF_PROB_SIZE), true);
1075     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_WEBVTT, TEST_FILE_URI_FMP4, DEF_PROB_SIZE), true);
1076     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_WEBVTT, TEST_FILE_URI_M4A, DEF_PROB_SIZE), true);
1077     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_WEBVTT, TEST_FILE_URI_MATROSKA, DEF_PROB_SIZE),
1078         true);
1079     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_WEBVTT, TEST_FILE_URI_MP3, DEF_PROB_SIZE), true);
1080     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_WEBVTT, TEST_FILE_URI_MPEG, DEF_PROB_SIZE), true);
1081     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_WEBVTT, TEST_FILE_URI_MPEGTS, DEF_PROB_SIZE), true);
1082     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_WEBVTT, TEST_FILE_URI_AVI, DEF_PROB_SIZE), true);
1083     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_WEBVTT, TEST_FILE_URI_SRT, DEF_PROB_SIZE), true);
1084     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_WEBVTT, TEST_FILE_URI_OGG, DEF_PROB_SIZE), true);
1085     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_WEBVTT, TEST_FILE_URI_WAV, DEF_PROB_SIZE), true);
1086 }
1087 
1088 /**
1089  * @tc.number    : DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0032
1090  * @tc.name      : create plugin by avdemux_ogg, container format is not ogg
1091  * @tc.desc      : function test
1092  */
1093 HWTEST_F(DemuxerPluginInnerFuncTest, DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0032, TestSize.Level2)
1094 {
1095     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_OGG, TEST_FILE_URI_AAC, DEF_PROB_SIZE), true);
1096     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_OGG, TEST_FILE_URI_AMRNB, DEF_PROB_SIZE), true);
1097     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_OGG, TEST_FILE_URI_AMRWB, DEF_PROB_SIZE), true);
1098     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_OGG, TEST_FILE_URI_APE, DEF_PROB_SIZE), true);
1099     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_OGG, TEST_FILE_URI_FLV, DEF_PROB_SIZE), true);
1100     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_OGG, TEST_FILE_URI_FLAC, DEF_PROB_SIZE), true);
1101     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_OGG, TEST_FILE_URI_MOV, DEF_PROB_SIZE), true);
1102     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_OGG, TEST_FILE_URI_MP4, DEF_PROB_SIZE), true);
1103     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_OGG, TEST_FILE_URI_FMP4, DEF_PROB_SIZE), true);
1104     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_OGG, TEST_FILE_URI_M4A, DEF_PROB_SIZE), true);
1105     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_OGG, TEST_FILE_URI_MATROSKA, DEF_PROB_SIZE), true);
1106     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_OGG, TEST_FILE_URI_MP3, DEF_PROB_SIZE), true);
1107     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_OGG, TEST_FILE_URI_MPEG, DEF_PROB_SIZE), true);
1108     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_OGG, TEST_FILE_URI_MPEGTS, DEF_PROB_SIZE), true);
1109     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_OGG, TEST_FILE_URI_AVI, DEF_PROB_SIZE), true);
1110     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_OGG, TEST_FILE_URI_SRT, DEF_PROB_SIZE), true);
1111     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_OGG, TEST_FILE_URI_WEBVTT, DEF_PROB_SIZE), true);
1112     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_OGG, TEST_FILE_URI_WAV, DEF_PROB_SIZE), true);
1113 }
1114 
1115 /**
1116  * @tc.number    : DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0033
1117  * @tc.name      : create plugin by avdemux_wav, container format is not wav
1118  * @tc.desc      : function test
1119  */
1120 HWTEST_F(DemuxerPluginInnerFuncTest, DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0033, TestSize.Level2)
1121 {
1122     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_WAV, TEST_FILE_URI_AAC, DEF_PROB_SIZE), true);
1123     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_WAV, TEST_FILE_URI_AMRNB, DEF_PROB_SIZE), true);
1124     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_WAV, TEST_FILE_URI_AMRWB, DEF_PROB_SIZE), true);
1125     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_WAV, TEST_FILE_URI_APE, DEF_PROB_SIZE), true);
1126     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_WAV, TEST_FILE_URI_FLV, DEF_PROB_SIZE), true);
1127     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_WAV, TEST_FILE_URI_FLAC, DEF_PROB_SIZE), true);
1128     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_WAV, TEST_FILE_URI_MOV, DEF_PROB_SIZE), true);
1129     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_WAV, TEST_FILE_URI_MP4, DEF_PROB_SIZE), true);
1130     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_WAV, TEST_FILE_URI_FMP4, DEF_PROB_SIZE), true);
1131     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_WAV, TEST_FILE_URI_M4A, DEF_PROB_SIZE), true);
1132     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_WAV, TEST_FILE_URI_MATROSKA, DEF_PROB_SIZE), true);
1133     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_WAV, TEST_FILE_URI_MP3, DEF_PROB_SIZE), true);
1134     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_WAV, TEST_FILE_URI_MPEG, DEF_PROB_SIZE), true);
1135     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_WAV, TEST_FILE_URI_MPEGTS, DEF_PROB_SIZE), true);
1136     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_WAV, TEST_FILE_URI_AVI, DEF_PROB_SIZE), true);
1137     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_WAV, TEST_FILE_URI_SRT, DEF_PROB_SIZE), true);
1138     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_WAV, TEST_FILE_URI_WEBVTT, DEF_PROB_SIZE), true);
1139     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_WAV, TEST_FILE_URI_OGG, DEF_PROB_SIZE), true);
1140 }
1141 
1142 /**
1143  * @tc.number    : DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0034
1144  * @tc.name      : create plugin by avdemux_flv, container format is not flv
1145  * @tc.desc      : function test
1146  */
1147 HWTEST_F(DemuxerPluginInnerFuncTest, DEMUXER_CREATE_PLUGIN_BY_NAME_INNER_FUNC_0034, TestSize.Level0)
1148 {
1149     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_FLV, TEST_FILE_URI_AAC, DEF_PROB_SIZE), true);
1150     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_FLV, TEST_FILE_URI_AMRNB, DEF_PROB_SIZE), true);
1151     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_FLV, TEST_FILE_URI_AMRWB, DEF_PROB_SIZE), true);
1152     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_FLV, TEST_FILE_URI_APE, DEF_PROB_SIZE), true);
1153     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_FLV, TEST_FILE_URI_WAV, DEF_PROB_SIZE), true);
1154     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_FLV, TEST_FILE_URI_FLAC, DEF_PROB_SIZE), true);
1155     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_FLV, TEST_FILE_URI_MOV, DEF_PROB_SIZE), true);
1156     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_FLV, TEST_FILE_URI_MP4, DEF_PROB_SIZE), true);
1157     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_FLV, TEST_FILE_URI_FMP4, DEF_PROB_SIZE), true);
1158     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_FLV, TEST_FILE_URI_M4A, DEF_PROB_SIZE), true);
1159     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_FLV, TEST_FILE_URI_MATROSKA, DEF_PROB_SIZE), true);
1160     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_FLV, TEST_FILE_URI_MP3, DEF_PROB_SIZE), true);
1161     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_FLV, TEST_FILE_URI_MPEG, DEF_PROB_SIZE), true);
1162     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_FLV, TEST_FILE_URI_MPEGTS, DEF_PROB_SIZE), true);
1163     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_FLV, TEST_FILE_URI_AVI, DEF_PROB_SIZE), true);
1164     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_FLV, TEST_FILE_URI_SRT, DEF_PROB_SIZE), true);
1165     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_FLV, TEST_FILE_URI_WEBVTT, DEF_PROB_SIZE), true);
1166     ASSERT_EQ(CreateDemuxerPluginByNotExistName(DEMUXER_PLUGIN_NAME_FLV, TEST_FILE_URI_OGG, DEF_PROB_SIZE), true);
1167 }
1168 }  // namespace Media
1169 }  // namespace OHOS