1 /*
2  * Copyright (C) 2023 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 "codeclist_unit_test.h"
17 #include <fcntl.h>
18 #include <fstream>
19 #include <iostream>
20 #include <string>
21 #include <vector>
22 #include "gtest/gtest.h"
23 
24 using namespace testing::ext;
25 using namespace OHOS::MediaAVCodec;
26 using namespace OHOS::MediaAVCodec::CodecListTestParam;
27 
SetUpTestCase()28 void CodecListUnitTest::SetUpTestCase() {}
29 
TearDownTestCase()30 void CodecListUnitTest::TearDownTestCase() {}
31 
SetUp()32 void CodecListUnitTest::SetUp() {}
33 
TearDown()34 void CodecListUnitTest::TearDown() {}
35 
VectorToString(const std::vector<int32_t> list,const std::string listName)36 string VectorToString(const std::vector<int32_t> list, const std::string listName)
37 {
38     std::string ret = listName;
39     ret += "={";
40     for (auto it = list.begin(); it != list.end(); ++it) {
41         ret += std::to_string(*it) + ", ";
42     }
43     ret += "}";
44     return ret;
45 }
46 
47 /**
48  * @tc.name: CodecList_GetCapabilityByCategory_001
49  * @tc.desc: CodecList GetCapabilityByCategory
50  * @tc.type: FUNC
51  */
52 HWTEST_F(CodecListUnitTest, CodecList_GetCapabilityByCategory_001, TestSize.Level1)
53 {
54     capability_ = CodecListMockFactory::GetCapability(DEFAULT_VIDEO_MIME, false);
55     if (capability_ != nullptr && capability_->IsHardware()) {
56         isHardIncluded_ = true;
57     }
58     AVCodecCategory category;
59     if (isHardIncluded_) {
60         category = AVCodecCategory::AVCODEC_HARDWARE;
61         capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_MIME, false, category);
62         EXPECT_NE(nullptr, capability_);
63 
64         capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_MIME, true, category);
65         EXPECT_NE(nullptr, capability_);
66     }
67     category = AVCodecCategory::AVCODEC_SOFTWARE;
68     capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_AUDIO_MIME, false, category);
69     EXPECT_NE(nullptr, capability_);
70 
71     capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_AUDIO_MIME, true, category);
72     EXPECT_NE(nullptr, capability_);
73 
74     capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_MIME, false, category);
75     EXPECT_NE(nullptr, capability_);
76 }
77 
78 /**
79  * @tc.name: CodecList_GetCapability_001
80  * @tc.desc: CodecList GetCapability
81  * @tc.type: FUNC
82  */
83 HWTEST_F(CodecListUnitTest, CodecList_GetCapability_001, TestSize.Level1)
84 {
85     for (auto it = CAPABILITY_DECODER_NAME.begin(); it != CAPABILITY_DECODER_NAME.end(); ++it) {
86         std::string mime = it->first;
87         capability_ = CodecListMockFactory::GetCapability(mime, false);
88         EXPECT_NE(nullptr, capability_) << mime << " can not found!" << std::endl;
89     }
90     for (auto it = CAPABILITY_ENCODER_NAME.begin(); it != CAPABILITY_ENCODER_NAME.end(); ++it) {
91         std::string mime = it->first;
92         capability_ = CodecListMockFactory::GetCapability(mime, true);
93         EXPECT_NE(nullptr, capability_) << mime << " can not found!" << std::endl;
94     }
95     if (isHardIncluded_) {
96         for (auto it = CAPABILITY_DECODER_HARD_NAME.begin(); it != CAPABILITY_DECODER_HARD_NAME.end(); ++it) {
97             std::string mime = it->first;
98             capability_ = CodecListMockFactory::GetCapability(mime, false);
99             EXPECT_NE(nullptr, capability_) << mime << " can not found!" << std::endl;
100         }
101 
102         for (auto it = CAPABILITY_ENCODER_HARD_NAME.begin(); it != CAPABILITY_ENCODER_HARD_NAME.end(); ++it) {
103             std::string mime = it->first;
104             capability_ = CodecListMockFactory::GetCapability(mime, true);
105             EXPECT_NE(nullptr, capability_) << mime << " can not found!" << std::endl;
106         }
107     }
108 }
109 
110 /**
111  * @tc.name: CodecList_IsHardware_001
112  * @tc.desc: CodecList IsHardware
113  * @tc.type: FUNC
114  */
115 HWTEST_F(CodecListUnitTest, CodecList_IsHardware_001, TestSize.Level1)
116 {
117     // audio decoder
118     AVCodecCategory category = AVCodecCategory::AVCODEC_SOFTWARE;
119     capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_AUDIO_MIME, false, category);
120     ASSERT_NE(nullptr, capability_);
121     EXPECT_FALSE(capability_->IsHardware());
122 
123     // audio encoder
124     category = AVCodecCategory::AVCODEC_SOFTWARE;
125     capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_AUDIO_MIME, false, category);
126     ASSERT_NE(nullptr, capability_);
127     EXPECT_FALSE(capability_->IsHardware());
128 
129     // video decoder
130     category = AVCodecCategory::AVCODEC_SOFTWARE;
131     capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_MIME, false, category);
132     ASSERT_NE(nullptr, capability_);
133     EXPECT_FALSE(capability_->IsHardware());
134 
135     if (isHardIncluded_) {
136         category = AVCodecCategory::AVCODEC_HARDWARE;
137         capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_MIME, false, category);
138         EXPECT_NE(nullptr, capability_);
139         EXPECT_FALSE(capability_->IsHardware());
140     }
141 }
142 
143 /**
144  * @tc.name: CodecList_GetName_001
145  * @tc.desc: CodecList GetName
146  * @tc.type: FUNC
147  */
148 HWTEST_F(CodecListUnitTest, CodecList_GetName_001, TestSize.Level1)
149 {
150     for (auto it = CAPABILITY_DECODER_NAME.begin(); it != CAPABILITY_DECODER_NAME.end(); ++it) {
151         std::string mime = it->first;
152         std::string nameOfMime = it->second;
153         AVCodecCategory category = AVCodecCategory::AVCODEC_SOFTWARE;
154         capability_ = CodecListMockFactory::GetCapabilityByCategory(mime, false, category);
155         ASSERT_NE(nullptr, capability_) << mime << " can not found!" << std::endl;
156         std::string codecName = capability_->GetName();
157         EXPECT_EQ(nameOfMime, codecName) << mime << " get error name: " << codecName << std::endl;
158         std::cout << "codecName is out : " << codecName << std::endl;
159         // std::cout << "codecName addr is out : " << (void*)codecName << std::endl;
160     }
161     for (auto it = CAPABILITY_ENCODER_NAME.begin(); it != CAPABILITY_ENCODER_NAME.end(); ++it) {
162         std::string mime = it->first;
163         std::string nameOfMime = it->second;
164         AVCodecCategory category = AVCodecCategory::AVCODEC_SOFTWARE;
165         capability_ = CodecListMockFactory::GetCapabilityByCategory(mime, true, category);
166         ASSERT_NE(nullptr, capability_) << mime << " can not found!" << std::endl;
167         std::string codecName = capability_->GetName();
168         if (mime == std::string(CodecMimeType::AUDIO_AAC)) {
169             bool check = (codecName == nameOfMime ||
170                           codecName == std::string(AVCodecCodecName::AUDIO_ENCODER_VENDOR_AAC_NAME));
171             EXPECT_EQ(true, check) << mime << " get error name: " << codecName << std::endl;
172         } else {
173             EXPECT_EQ(nameOfMime, codecName) << mime << " get error name: " << codecName << std::endl;
174         }
175     }
176     if (isHardIncluded_) {
177         for (auto it = CAPABILITY_DECODER_HARD_NAME.begin(); it != CAPABILITY_DECODER_HARD_NAME.end(); ++it) {
178             std::string mime = it->first;
179             std::string nameOfMime = it->second;
180             capability_ = CodecListMockFactory::GetCapability(mime, false);
181             ASSERT_NE(nullptr, capability_) << mime << " can not found!" << std::endl;
182             std::string codecName = capability_->GetName();
183             EXPECT_EQ(nameOfMime, codecName) << mime << " get error name: " << codecName << std::endl;
184         }
185         for (auto it = CAPABILITY_ENCODER_HARD_NAME.begin(); it != CAPABILITY_ENCODER_HARD_NAME.end(); ++it) {
186             std::string mime = it->first;
187             std::string nameOfMime = it->second;
188             capability_ = CodecListMockFactory::GetCapability(mime, true);
189             ASSERT_NE(nullptr, capability_) << mime << " can not found!" << std::endl;
190             std::string codecName = capability_->GetName();
191             if (codecName != "") {
192                 EXPECT_EQ(nameOfMime, codecName) << mime << " get error name: " << codecName << std::endl;
193             }
194         }
195     }
196 }
197 
198 /**
199  * @tc.name: CodecList_GetMaxSupportedInstances_001
200  * @tc.desc: CodecList GetMaxSupportedInstances
201  * @tc.type: FUNC
202  */
203 HWTEST_F(CodecListUnitTest, CodecList_GetMaxSupportedInstances_001, TestSize.Level1)
204 {
205     // audio decoder
206     capability_ = CodecListMockFactory::GetCapability(DEFAULT_AUDIO_MIME, false);
207     ASSERT_NE(nullptr, capability_) << "audio decoder codeclist create fail!" << std::endl;
208     EXPECT_EQ(MAX_SURPPORT_ACODEC, capability_->GetMaxSupportedInstances());
209 
210     // audio encoder
211     capability_ = CodecListMockFactory::GetCapability(DEFAULT_AUDIO_MIME, true);
212     ASSERT_NE(nullptr, capability_) << "audio encoder codeclist create fail!" << std::endl;
213     EXPECT_EQ(MAX_SURPPORT_ACODEC, capability_->GetMaxSupportedInstances());
214 
215     // video decoder
216     AVCodecCategory category = AVCodecCategory::AVCODEC_SOFTWARE;
217     capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_MIME, false, category);
218     ASSERT_NE(nullptr, capability_) << "video decoder codeclist create fail!" << std::endl;
219     EXPECT_EQ(MAX_SURPPORT_VCODEC, capability_->GetMaxSupportedInstances());
220 }
221 
222 /**
223  * @tc.name: CodecList_GetEncoderBitrateRange_001
224  * @tc.desc: CodecList GetEncoderBitrateRange
225  * @tc.type: FUNC
226  */
227 HWTEST_F(CodecListUnitTest, CodecList_GetEncoderBitrateRange_001, TestSize.Level1)
228 {
229     // audio encoder
230     capability_ = CodecListMockFactory::GetCapability(DEFAULT_AUDIO_MIME, true);
231     ASSERT_NE(nullptr, capability_) << "audio encoder codeclist create fail!" << std::endl;
232     Range bitrateRange = capability_->GetEncoderBitrateRange();
233     EXPECT_EQ(DEFAULT_BITRATE_RANGE.minVal, bitrateRange.minVal);
234     EXPECT_EQ(DEFAULT_BITRATE_RANGE.maxVal, bitrateRange.maxVal);
235 }
236 
237 /**
238  * @tc.name: CodecList_IsEncoderBitrateModeSupported_001
239  * @tc.desc: CodecList IsEncoderBitrateModeSupported
240  * @tc.type: FUNC
241  */
242 HWTEST_F(CodecListUnitTest, CodecList_IsEncoderBitrateModeSupported_001, TestSize.Level1)
243 {
244     // audio encoder
245     capability_ = CodecListMockFactory::GetCapability(DEFAULT_AUDIO_MIME, true);
246     ASSERT_NE(nullptr, capability_) << "audio encoder codeclist create fail!" << std::endl;
247 
248     // positive case
249     OH_BitrateMode bitrateMode = OH_BitrateMode::BITRATE_MODE_CBR;
250     EXPECT_FALSE(capability_->IsEncoderBitrateModeSupported(bitrateMode));
251 
252     // negative case
253     bitrateMode = OH_BitrateMode::BITRATE_MODE_VBR;
254     EXPECT_FALSE(capability_->IsEncoderBitrateModeSupported(bitrateMode));
255 }
256 
257 /**
258  * @tc.name: CodecList_GetEncoderQualityRange_001
259  * @tc.desc: CodecList GetEncoderQualityRange
260  * @tc.type: FUNC
261  */
262 HWTEST_F(CodecListUnitTest, CodecList_GetEncoderQualityRange_001, TestSize.Level1)
263 {
264     // audio encoder
265     capability_ = CodecListMockFactory::GetCapability(DEFAULT_AUDIO_MIME, true);
266     ASSERT_NE(nullptr, capability_) << "audio encoder codeclist create fail!" << std::endl;
267 
268     Range qualityRange = capability_->GetEncoderQualityRange();
269     EXPECT_EQ(DEFAULT_QUALITY_RANGE.minVal, qualityRange.minVal);
270     EXPECT_EQ(DEFAULT_QUALITY_RANGE.maxVal, qualityRange.maxVal);
271 }
272 
273 /**
274  * @tc.name: CodecList_GetEncoderComplexityRange_001
275  * @tc.desc: CodecList GetEncoderComplexityRange
276  * @tc.type: FUNC
277  */
278 HWTEST_F(CodecListUnitTest, CodecList_GetEncoderComplexityRange_001, TestSize.Level1)
279 {
280     // audio encoder
281     capability_ = CodecListMockFactory::GetCapability(DEFAULT_AUDIO_MIME, true);
282     ASSERT_NE(nullptr, capability_) << "audio encoder codeclist create fail!" << std::endl;
283 
284     Range complexityRange = capability_->GetEncoderComplexityRange();
285     EXPECT_EQ(DEFAULT_COMPLEXITY_RANGE.minVal, complexityRange.minVal);
286     EXPECT_EQ(DEFAULT_COMPLEXITY_RANGE.maxVal, complexityRange.maxVal);
287 }
288 
289 /**
290  * @tc.name: CodecList_GetAudioSupportedSampleRates_001
291  * @tc.desc: CodecList GetAudioSupportedSampleRates
292  * @tc.type: FUNC
293  */
294 HWTEST_F(CodecListUnitTest, CodecList_GetAudioSupportedSampleRates_001, TestSize.Level1)
295 {
296     // audio encoder
297     capability_ = CodecListMockFactory::GetCapability(DEFAULT_AUDIO_MIME, true);
298     ASSERT_NE(nullptr, capability_) << "audio encoder codeclist create fail!" << std::endl;
299     std::vector<int32_t> sampleRates = capability_->GetAudioSupportedSampleRates();
300     EXPECT_EQ(DEFAULT_AUDIO_ACC_SAMPLES, sampleRates);
301 }
302 
303 /**
304  * @tc.name: CodecList_GetAudioChannelsRange_001
305  * @tc.desc: CodecList GetAudioChannelsRange
306  * @tc.type: FUNC
307  */
308 HWTEST_F(CodecListUnitTest, CodecList_GetAudioChannelsRange_001, TestSize.Level1)
309 {
310     // audio encoder
311     capability_ = CodecListMockFactory::GetCapability(DEFAULT_AUDIO_MIME, true);
312     ASSERT_NE(nullptr, capability_) << "audio encoder codeclist create fail!" << std::endl;
313 
314     Range channelCountRange = capability_->GetAudioChannelsRange();
315     EXPECT_EQ(DEFAULT_CHANNELCOUNT_RANGE.minVal, channelCountRange.minVal);
316     EXPECT_EQ(DEFAULT_CHANNELCOUNT_RANGE.maxVal, channelCountRange.maxVal);
317 }
318 
319 /**
320  * @tc.name: CodecList_GetVideoWidthAlignment_001
321  * @tc.desc: CodecList GetVideoWidthAlignment
322  * @tc.type: FUNC
323  */
324 HWTEST_F(CodecListUnitTest, CodecList_GetVideoWidthAlignment_001, TestSize.Level1)
325 {
326     // video decoder
327     AVCodecCategory category = AVCodecCategory::AVCODEC_SOFTWARE;
328     capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_MIME, false, category);
329     ASSERT_NE(nullptr, capability_) << "video decoder codeclist create fail!" << std::endl;
330 
331     int32_t widthAlignment = capability_->GetVideoWidthAlignment();
332     EXPECT_EQ(DEFAULT_WIDTH_ALIGNMENT, widthAlignment);
333 }
334 
335 /**
336  * @tc.name: CodecList_GetVideoHeightAlignment_001
337  * @tc.desc: CodecList GetVideoHeightAlignment
338  * @tc.type: FUNC
339  */
340 HWTEST_F(CodecListUnitTest, CodecList_GetVideoHeightAlignment_001, TestSize.Level1)
341 {
342     // video decoder
343     AVCodecCategory category = AVCodecCategory::AVCODEC_SOFTWARE;
344     capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_MIME, false, category);
345     ASSERT_NE(nullptr, capability_) << "video decoder codeclist create fail!" << std::endl;
346 
347     int32_t heightAlignment = capability_->GetVideoHeightAlignment();
348     EXPECT_EQ(DEFAULT_HEIGHT_ALIGNMENT, heightAlignment);
349 }
350 
351 /**
352  * @tc.name: CodecList_GetVideoHeightRangeForWidth_001
353  * @tc.desc: CodecList GetVideoHeightRangeForWidth
354  * @tc.type: FUNC
355  */
356 HWTEST_F(CodecListUnitTest, CodecList_GetVideoHeightRangeForWidth_001, TestSize.Level1)
357 {
358     // video decoder
359     AVCodecCategory category = AVCodecCategory::AVCODEC_SOFTWARE;
360     capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_MIME, false, category);
361     ASSERT_NE(nullptr, capability_) << "video decoder codeclist create fail!" << std::endl;
362 
363     Range widthRange = capability_->GetVideoHeightRangeForWidth(DEFAULT_WIDTH);
364     EXPECT_EQ(DEFAULT_WIDTH_RANGE.minVal, widthRange.minVal);
365     EXPECT_EQ(DEFAULT_WIDTH_RANGE.maxVal, widthRange.maxVal);
366 }
367 
368 /**
369  * @tc.name: CodecList_GetVideoWidthRangeForHeight_001
370  * @tc.desc: CodecList GetVideoWidthRangeForHeight
371  * @tc.type: FUNC
372  */
373 HWTEST_F(CodecListUnitTest, CodecList_GetVideoWidthRangeForHeight_001, TestSize.Level1)
374 {
375     // video decoder
376     AVCodecCategory category = AVCodecCategory::AVCODEC_SOFTWARE;
377     capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_MIME, false, category);
378     ASSERT_NE(nullptr, capability_) << "video decoder codeclist create fail!" << std::endl;
379 
380     Range heightRange = capability_->GetVideoWidthRangeForHeight(DEFAULT_HEIGHT);
381     EXPECT_EQ(DEFAULT_HEIGHT_RANGE_OF_WIDTH.minVal, heightRange.minVal);
382     EXPECT_EQ(DEFAULT_HEIGHT_RANGE_OF_WIDTH.maxVal, heightRange.maxVal);
383 }
384 
385 /**
386  * @tc.name: CodecList_GetVideoWidthRange_001
387  * @tc.desc: CodecList GetVideoWidthRange
388  * @tc.type: FUNC
389  */
390 HWTEST_F(CodecListUnitTest, CodecList_GetVideoWidthRange_001, TestSize.Level1)
391 {
392     // video decoder
393     AVCodecCategory category = AVCodecCategory::AVCODEC_SOFTWARE;
394     capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_MIME, false, category);
395     ASSERT_NE(nullptr, capability_) << "video decoder codeclist create fail!" << std::endl;
396 
397     Range widthRange = capability_->GetVideoWidthRange();
398     EXPECT_EQ(DEFAULT_WIDTH_RANGE.minVal, widthRange.minVal);
399     EXPECT_EQ(DEFAULT_WIDTH_RANGE.maxVal, widthRange.maxVal);
400 }
401 
402 /**
403  * @tc.name: CodecList_GetVideoHeightRange_001
404  * @tc.desc: CodecList GetVideoHeightRange
405  * @tc.type: FUNC
406  */
407 HWTEST_F(CodecListUnitTest, CodecList_GetVideoHeightRange_001, TestSize.Level1)
408 {
409     // video decoder
410     AVCodecCategory category = AVCodecCategory::AVCODEC_SOFTWARE;
411     capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_MIME, false, category);
412     ASSERT_NE(nullptr, capability_) << "video decoder codeclist create fail!" << std::endl;
413 
414     Range heightRange = capability_->GetVideoHeightRange();
415     EXPECT_EQ(DEFAULT_HEIGHT_RANGE.minVal, heightRange.minVal);
416     EXPECT_EQ(DEFAULT_HEIGHT_RANGE.maxVal, heightRange.maxVal);
417 }
418 
419 /**
420  * @tc.name: CodecList_IsVideoSizeSupported_001
421  * @tc.desc: CodecList IsVideoSizeSupported
422  * @tc.type: FUNC
423  */
424 HWTEST_F(CodecListUnitTest, CodecList_IsVideoSizeSupported_001, TestSize.Level1)
425 {
426     // video decoder
427     AVCodecCategory category = AVCodecCategory::AVCODEC_SOFTWARE;
428     capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_MIME, false, category);
429     ASSERT_NE(nullptr, capability_) << "video decoder codeclist create fail!" << std::endl;
430 
431     int32_t wmin = DEFAULT_WIDTH_RANGE.minVal;
432     int32_t wmax = DEFAULT_WIDTH_RANGE.maxVal;
433     int32_t hmin = DEFAULT_HEIGHT_RANGE.minVal;
434     int32_t hmax = DEFAULT_HEIGHT_RANGE.maxVal;
435     // case 1 - 13, postive param
436     EXPECT_TRUE(capability_->IsVideoSizeSupported(DEFAULT_WIDTH, DEFAULT_HEIGHT))
437         << "width:" << DEFAULT_WIDTH << "height:" << DEFAULT_HEIGHT << std::endl;
438     EXPECT_TRUE(capability_->IsVideoSizeSupported(wmin, DEFAULT_HEIGHT))
439         << "width:" << wmin << "height:" << DEFAULT_HEIGHT << std::endl;
440     EXPECT_TRUE(capability_->IsVideoSizeSupported(wmin + 2, DEFAULT_HEIGHT))
441         << "width:" << wmin + 2 << "height:" << DEFAULT_HEIGHT << std::endl;
442     EXPECT_TRUE(capability_->IsVideoSizeSupported(wmin + 2, hmax))
443         << "width:" << wmin + 2 << "height:" << hmax << std::endl;
444     EXPECT_TRUE(capability_->IsVideoSizeSupported(wmin + 2, hmax - 2))
445         << "width:" << wmin + 2 << "height:" << hmax - 2 << std::endl;
446     EXPECT_TRUE(capability_->IsVideoSizeSupported(DEFAULT_WIDTH, hmax))
447         << "width:" << DEFAULT_WIDTH << "height:" << hmax << std::endl;
448     EXPECT_TRUE(capability_->IsVideoSizeSupported(DEFAULT_WIDTH, hmax - 2))
449         << "width:" << DEFAULT_WIDTH << "height:" << hmax - 2 << std::endl;
450     EXPECT_TRUE(capability_->IsVideoSizeSupported(wmax, DEFAULT_HEIGHT))
451         << "width:" << wmax << "height:" << DEFAULT_HEIGHT << std::endl;
452     EXPECT_TRUE(capability_->IsVideoSizeSupported(wmax - 2, DEFAULT_HEIGHT))
453         << "width:" << wmax - 2 << "height:" << DEFAULT_HEIGHT << std::endl;
454     EXPECT_TRUE(capability_->IsVideoSizeSupported(wmax - 2, hmin))
455         << "width:" << wmax - 2 << "height:" << DEFAULT_HEIGHT << std::endl;
456     EXPECT_TRUE(capability_->IsVideoSizeSupported(wmax - 2, hmin + 2))
457         << "width:" << wmax - 2 << "height:" << hmin + 2 << std::endl;
458     EXPECT_TRUE(capability_->IsVideoSizeSupported(DEFAULT_WIDTH, hmin))
459         << "width:" << DEFAULT_WIDTH << "height:" << hmin << std::endl;
460     EXPECT_TRUE(capability_->IsVideoSizeSupported(DEFAULT_WIDTH, hmin + 2))
461         << "width:" << DEFAULT_WIDTH << "height:" << hmin + 2 << std::endl;
462 }
463 
464 /**
465  * @tc.name: CodecList_IsVideoSizeSupported_002
466  * @tc.desc: CodecList IsVideoSizeSupported
467  * @tc.type: FUNC
468  */
469 HWTEST_F(CodecListUnitTest, CodecList_IsVideoSizeSupported_002, TestSize.Level1)
470 {
471     // video decoder
472     AVCodecCategory category = AVCodecCategory::AVCODEC_SOFTWARE;
473     capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_MIME, false, category);
474     ASSERT_NE(nullptr, capability_) << "video decoder codeclist create fail!" << std::endl;
475 
476     int32_t wmin = DEFAULT_WIDTH_RANGE.minVal;
477     int32_t wmax = DEFAULT_WIDTH_RANGE.maxVal;
478     int32_t hmin = DEFAULT_HEIGHT_RANGE.minVal;
479     int32_t hmax = DEFAULT_HEIGHT_RANGE.maxVal;
480     // case 1 - 10, negative param
481     EXPECT_FALSE(capability_->IsVideoSizeSupported(wmax + 2, hmin))
482         << "width:" << wmin + 2 << "height:" << hmin << std::endl;
483     EXPECT_FALSE(capability_->IsVideoSizeSupported(wmin - 2, hmin))
484         << "width:" << wmin - 2 << "height:" << hmin << std::endl;
485     EXPECT_FALSE(capability_->IsVideoSizeSupported(wmax + 2, hmax))
486         << "width:" << wmin + 2 << "height:" << hmax << std::endl;
487     EXPECT_FALSE(capability_->IsVideoSizeSupported(wmin - 2, hmax))
488         << "width:" << wmin - 2 << "height:" << hmax << std::endl;
489 
490     EXPECT_FALSE(capability_->IsVideoSizeSupported(wmin, hmin - 2))
491         << "width:" << wmin << "height:" << hmin - 2 << std::endl;
492     EXPECT_FALSE(capability_->IsVideoSizeSupported(wmin, hmax + 2))
493         << "width:" << wmin << "height:" << hmax + 2 << std::endl;
494     EXPECT_FALSE(capability_->IsVideoSizeSupported(wmax, hmin - 2))
495         << "width:" << wmax << "height:" << hmin - 2 << std::endl;
496     EXPECT_FALSE(capability_->IsVideoSizeSupported(wmax, hmax + 2))
497         << "width:" << wmax << "height:" << hmax + 2 << std::endl;
498 
499     EXPECT_FALSE(capability_->IsVideoSizeSupported(DEFAULT_WIDTH + 1, DEFAULT_HEIGHT))
500         << "width:" << DEFAULT_WIDTH + 1 << "height:" << DEFAULT_HEIGHT << std::endl;
501     EXPECT_FALSE(capability_->IsVideoSizeSupported(DEFAULT_WIDTH, DEFAULT_HEIGHT + 1))
502         << "width:" << DEFAULT_WIDTH << "height:" << DEFAULT_HEIGHT + 1 << std::endl;
503 }
504 
505 /**
506  * @tc.name: CodecList_GetVideoFrameRateRange_001
507  * @tc.desc: CodecList GetVideoFrameRateRange
508  * @tc.type: FUNC
509  */
510 HWTEST_F(CodecListUnitTest, CodecList_GetVideoFrameRateRange_001, TestSize.Level1)
511 {
512     // video decoder
513     AVCodecCategory category = AVCodecCategory::AVCODEC_SOFTWARE;
514     capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_MIME, false, category);
515     ASSERT_NE(nullptr, capability_) << "video decoder codeclist create fail!" << std::endl;
516 
517     Range framerateRange = capability_->GetVideoFrameRateRange();
518     EXPECT_EQ(DEFAULT_FRAMERATE_RANGE.minVal, framerateRange.minVal);
519     EXPECT_EQ(DEFAULT_FRAMERATE_RANGE.maxVal, framerateRange.maxVal);
520 }
521 
522 /**
523  * @tc.name: CodecList_AreVideoSizeAndFrameRateSupported_001
524  * @tc.desc: CodecList AreVideoSizeAndFrameRateSupported
525  * @tc.type: FUNC
526  */
527 HWTEST_F(CodecListUnitTest, CodecList_AreVideoSizeAndFrameRateSupported_001, TestSize.Level1)
528 {
529     // video decoder
530     AVCodecCategory category = AVCodecCategory::AVCODEC_SOFTWARE;
531     capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_MIME, false, category);
532     ASSERT_NE(nullptr, capability_) << "video decoder codeclist create fail!" << std::endl;
533     int32_t minVal = DEFAULT_FRAMERATE_RANGE.minVal;
534     int32_t maxVal = DEFAULT_FRAMERATE_RANGE.maxVal;
535     // case 1 - 4, positive param
536     EXPECT_TRUE(capability_->AreVideoSizeAndFrameRateSupported(DEFAULT_WIDTH, DEFAULT_HEIGHT, DEFAULT_FRAMERATE))
537         << "width:" << DEFAULT_WIDTH << "height:" << DEFAULT_HEIGHT << "framerate: " << DEFAULT_FRAMERATE << std::endl;
538     EXPECT_TRUE(capability_->AreVideoSizeAndFrameRateSupported(DEFAULT_WIDTH, DEFAULT_HEIGHT, minVal + 1))
539         << "width:" << DEFAULT_WIDTH << "height:" << DEFAULT_HEIGHT << "framerate: " << minVal + 1 << std::endl;
540     EXPECT_TRUE(capability_->AreVideoSizeAndFrameRateSupported(DEFAULT_WIDTH, DEFAULT_HEIGHT, maxVal))
541         << "width:" << DEFAULT_WIDTH << "height:" << DEFAULT_HEIGHT << "framerate: " << maxVal << std::endl;
542     EXPECT_TRUE(capability_->AreVideoSizeAndFrameRateSupported(DEFAULT_WIDTH, DEFAULT_HEIGHT, maxVal - 1))
543         << "width:" << DEFAULT_WIDTH << "height:" << DEFAULT_HEIGHT << "framerate: " << maxVal - 1 << std::endl;
544 }
545 
546 /**
547  * @tc.name: CodecList_AreVideoSizeAndFrameRateSupported_002
548  * @tc.desc: CodecList AreVideoSizeAndFrameRateSupported
549  * @tc.type: FUNC
550  */
551 HWTEST_F(CodecListUnitTest, CodecList_AreVideoSizeAndFrameRateSupported_002, TestSize.Level1)
552 {
553     // video decoder
554     AVCodecCategory category = AVCodecCategory::AVCODEC_SOFTWARE;
555     capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_MIME, false, category);
556     ASSERT_NE(nullptr, capability_) << "video decoder codeclist create fail!" << std::endl;
557     int32_t minVal = DEFAULT_FRAMERATE_RANGE.minVal;
558     int32_t maxVal = DEFAULT_FRAMERATE_RANGE.maxVal;
559     // case 1 - 9, negative param
560     EXPECT_FALSE(capability_->AreVideoSizeAndFrameRateSupported(DEFAULT_WIDTH, DEFAULT_HEIGHT, minVal - 1))
561         << "width:" << DEFAULT_WIDTH << "height:" << DEFAULT_HEIGHT << "framerate: " << minVal - 1 << std::endl;
562     EXPECT_FALSE(capability_->AreVideoSizeAndFrameRateSupported(DEFAULT_WIDTH, DEFAULT_HEIGHT, maxVal + 1))
563         << "width:" << DEFAULT_WIDTH << "height:" << DEFAULT_HEIGHT << "framerate: " << minVal + 1 << std::endl;
564     EXPECT_FALSE(capability_->AreVideoSizeAndFrameRateSupported(DEFAULT_WIDTH, DEFAULT_HEIGHT, ERROR_FRAMERATE))
565         << "width:" << DEFAULT_WIDTH << "height:" << DEFAULT_HEIGHT << "framerate: " << ERROR_FRAMERATE << std::endl;
566     EXPECT_FALSE(capability_->AreVideoSizeAndFrameRateSupported(DEFAULT_WIDTH, ERROR_HEIGHT, DEFAULT_FRAMERATE))
567         << "width:" << DEFAULT_WIDTH << "height:" << ERROR_HEIGHT << "framerate: " << DEFAULT_FRAMERATE << std::endl;
568     EXPECT_FALSE(capability_->AreVideoSizeAndFrameRateSupported(DEFAULT_WIDTH, ERROR_HEIGHT, ERROR_FRAMERATE))
569         << "width:" << DEFAULT_WIDTH << "height:" << ERROR_HEIGHT << "framerate: " << ERROR_FRAMERATE << std::endl;
570     EXPECT_FALSE(capability_->AreVideoSizeAndFrameRateSupported(ERROR_WIDTH, DEFAULT_HEIGHT, DEFAULT_FRAMERATE))
571         << "width:" << ERROR_WIDTH << "height:" << DEFAULT_HEIGHT << "framerate: " << DEFAULT_FRAMERATE << std::endl;
572     EXPECT_FALSE(capability_->AreVideoSizeAndFrameRateSupported(ERROR_WIDTH, DEFAULT_HEIGHT, ERROR_FRAMERATE))
573         << "width:" << ERROR_WIDTH << "height:" << DEFAULT_HEIGHT << "framerate: " << ERROR_FRAMERATE << std::endl;
574     EXPECT_FALSE(capability_->AreVideoSizeAndFrameRateSupported(ERROR_WIDTH, ERROR_HEIGHT, DEFAULT_FRAMERATE))
575         << "width:" << ERROR_WIDTH << "height:" << ERROR_HEIGHT << "framerate: " << DEFAULT_FRAMERATE << std::endl;
576     EXPECT_FALSE(capability_->AreVideoSizeAndFrameRateSupported(ERROR_WIDTH, ERROR_HEIGHT, ERROR_FRAMERATE))
577         << "width:" << ERROR_WIDTH << "height:" << ERROR_HEIGHT << "framerate: " << ERROR_FRAMERATE << std::endl;
578 }
579 
580 /**
581  * @tc.name: CodecList_GetVideoFrameRateRangeForSize_001
582  * @tc.desc: CodecList GetVideoFrameRateRangeForSize
583  * @tc.type: FUNC
584  */
585 HWTEST_F(CodecListUnitTest, CodecList_GetVideoFrameRateRangeForSize_001, TestSize.Level1)
586 {
587     // video decoder
588     AVCodecCategory category = AVCodecCategory::AVCODEC_SOFTWARE;
589     capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_MIME, false, category);
590     ASSERT_NE(nullptr, capability_) << "video decoder codeclist create fail!" << std::endl;
591 
592     int32_t wmax = DEFAULT_HEIGHT_RANGE_OF_WIDTH.maxVal;
593     int32_t hmax = DEFAULT_WIDTH_RANGE_OF_HEIGHT.maxVal;
594     Range framerateRange = capability_->GetVideoFrameRateRangeForSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);
595     EXPECT_EQ(DEFAULT_FRAMERATE_RANGE.minVal, framerateRange.minVal);
596     EXPECT_EQ(DEFAULT_FRAMERATE_RANGE.maxVal, framerateRange.maxVal);
597 
598     framerateRange = capability_->GetVideoFrameRateRangeForSize(wmax, hmax);
599     EXPECT_EQ(0, framerateRange.minVal);
600     EXPECT_EQ(26, framerateRange.maxVal); // 26: The return values after (2304, 4096) are passed in
601 }
602 
603 /**
604  * @tc.name: CodecList_GetVideoFrameRateRangeForSize_002
605  * @tc.desc: CodecList GetVideoFrameRateRangeForSize
606  * @tc.type: FUNC
607  */
608 HWTEST_F(CodecListUnitTest, CodecList_GetVideoFrameRateRangeForSize_002, TestSize.Level1)
609 {
610     // video decoder
611     AVCodecCategory category = AVCodecCategory::AVCODEC_SOFTWARE;
612     capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_MIME, false, category);
613     ASSERT_NE(nullptr, capability_) << "video decoder codeclist create fail!" << std::endl;
614 
615     int32_t wmax = DEFAULT_WIDTH_RANGE.maxVal;
616     int32_t hmax = DEFAULT_HEIGHT_RANGE.maxVal;
617     Range framerateRange = capability_->GetVideoFrameRateRangeForSize(0, 0);
618     EXPECT_EQ(0, framerateRange.minVal);
619     EXPECT_EQ(0, framerateRange.maxVal);
620 
621     framerateRange = capability_->GetVideoFrameRateRangeForSize(wmax + 2, hmax + 2);
622     EXPECT_EQ(0, framerateRange.minVal);
623     EXPECT_EQ(0, framerateRange.maxVal);
624 
625     framerateRange = capability_->GetVideoFrameRateRangeForSize(wmax - 1, hmax - 1);
626     EXPECT_EQ(0, framerateRange.minVal);
627     EXPECT_EQ(0, framerateRange.maxVal);
628 
629     framerateRange = capability_->GetVideoFrameRateRangeForSize(-2, -2);
630     EXPECT_EQ(0, framerateRange.minVal);
631     EXPECT_EQ(0, framerateRange.maxVal);
632 }
633 
634 /**
635  * @tc.name: CodecList_GetVideoSupportedPixelFormats_001
636  * @tc.desc: CodecList GetVideoSupportedPixelFormats
637  * @tc.type: FUNC
638  */
639 HWTEST_F(CodecListUnitTest, CodecList_GetVideoSupportedPixelFormats_001, TestSize.Level1)
640 {
641     // video decoder
642     AVCodecCategory category = AVCodecCategory::AVCODEC_SOFTWARE;
643     capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_MIME, false, category);
644     ASSERT_NE(nullptr, capability_) << "video decoder codeclist create fail!" << std::endl;
645 
646     std::vector<int32_t> pixFormats = capability_->GetVideoSupportedPixelFormats();
647     EXPECT_EQ(DEFAULT_VIDEO_AVC_PIXFORMATS, pixFormats);
648 }
649 
650 /**
651  * @tc.name: CodecList_GetSupportedProfiles_001
652  * @tc.desc: CodecList GetSupportedProfiles
653  * @tc.type: FUNC
654  */
655 HWTEST_F(CodecListUnitTest, CodecList_GetSupportedProfiles_001, TestSize.Level1)
656 {
657     // video decoder
658     AVCodecCategory category = AVCodecCategory::AVCODEC_SOFTWARE;
659     capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_MIME, false, category);
660     ASSERT_NE(nullptr, capability_) << "video decoder codeclist create fail!" << std::endl;
661 
662     std::vector<int32_t> profiles = capability_->GetSupportedProfiles();
663     EXPECT_EQ(DEFAULT_VIDEO_AVC_PROFILES, profiles);
664 }
665 
666 /**
667  * @tc.name: CodecList_GetSupportedLevelsForProfile_001
668  * @tc.desc: CodecList GetSupportedLevelsForProfile
669  * @tc.type: FUNC
670  */
671 HWTEST_F(CodecListUnitTest, CodecList_GetSupportedLevelsForProfile_001, TestSize.Level1)
672 {
673     // video decoder
674     AVCodecCategory category = AVCodecCategory::AVCODEC_SOFTWARE;
675     capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_MIME, false, category);
676     ASSERT_NE(nullptr, capability_) << "video decoder codeclist create fail!" << std::endl;
677 
678     std::vector<int32_t> levels = capability_->GetSupportedLevelsForProfile(DEFAULT_VIDEO_AVC_PROFILE);
679     EXPECT_EQ(DEFAULT_VIDEO_AVC_LEVELS, levels);
680 }
681 
682 /**
683  * @tc.name: CodecList_AreProfileAndLevelSupported_001
684  * @tc.desc: CodecList AreProfileAndLevelSupported
685  * @tc.type: FUNC
686  */
687 HWTEST_F(CodecListUnitTest, CodecList_AreProfileAndLevelSupported_001, TestSize.Level1)
688 {
689     // video decoder
690     AVCodecCategory category = AVCodecCategory::AVCODEC_SOFTWARE;
691     capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_MIME, false, category);
692     ASSERT_NE(nullptr, capability_) << "video decoder codeclist create fail!" << std::endl;
693     // case 1 - 16, postive param
694     for (auto it : DEFAULT_VIDEO_AVC_LEVELS) {
695         EXPECT_TRUE(capability_->AreProfileAndLevelSupported(DEFAULT_VIDEO_AVC_PROFILE, it));
696     }
697 }
698 
699 /**
700  * @tc.name: CodecList_AreProfileAndLevelSupported_002
701  * @tc.desc: CodecList AreProfileAndLevelSupported
702  * @tc.type: FUNC
703  */
704 HWTEST_F(CodecListUnitTest, CodecList_AreProfileAndLevelSupported_002, TestSize.Level1)
705 {
706     // video decoder
707     AVCodecCategory category = AVCodecCategory::AVCODEC_SOFTWARE;
708     capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_MIME, false, category);
709     ASSERT_NE(nullptr, capability_) << "video decoder codeclist create fail!" << std::endl;
710     // case 1, negative param
711     EXPECT_FALSE(capability_->AreProfileAndLevelSupported(DEFAULT_VIDEO_AVC_PROFILE, ERROR_LEVEL));
712     // case 2, negative param
713     EXPECT_FALSE(capability_->AreProfileAndLevelSupported(ERROR_VIDEO_AVC_PROFILE, DEFAULT_LEVEL));
714     // case 3, negative param
715     EXPECT_FALSE(capability_->AreProfileAndLevelSupported(ERROR_VIDEO_AVC_PROFILE, ERROR_LEVEL));
716 }
717 
718 /**
719  * @tc.name: CodecList_UNSUPPORTED_MIME_001
720  * @tc.desc: CodecList use unsupprted mime
721  * @tc.type: FUNC
722  */
723 HWTEST_F(CodecListUnitTest, CodecList_UNSUPPORTED_MIME_001, TestSize.Level1)
724 {
725     capability_ = CodecListMockFactory::GetCapabilityByCategory(
726         DEFAULT_UNSUPPORTED_MIME, false, ::AVCodecCategory::AVCODEC_NONE);
727     if (capability_ != nullptr) {
728         EXPECT_EQ(capability_->GetName(), "");
729         EXPECT_EQ(capability_->IsHardware(), false);
730         EXPECT_EQ(capability_->IsEncoderBitrateModeSupported(OH_BitrateMode::BITRATE_MODE_CBR), false);
731         EXPECT_EQ(capability_->IsVideoSizeSupported(DEFAULT_WIDTH, DEFAULT_HEIGHT), false);
732         EXPECT_EQ(capability_->AreVideoSizeAndFrameRateSupported(
733             DEFAULT_WIDTH, DEFAULT_HEIGHT, DEFAULT_FRAMERATE), false);
734         EXPECT_EQ(capability_->AreProfileAndLevelSupported(DEFAULT_VIDEO_AVC_PROFILE, DEFAULT_LEVEL), false);
735         EXPECT_EQ(capability_->GetMaxSupportedInstances(), 0);
736         EXPECT_EQ(capability_->GetVideoWidthAlignment(), 1);
737         EXPECT_EQ(capability_->GetVideoHeightAlignment(), 1);
738         std::vector<int32_t> sampleRates = capability_->GetAudioSupportedSampleRates();
739         EXPECT_EQ(sampleRates.size(), 0);
740         std::vector<int32_t> profiles = capability_->GetSupportedProfiles();
741         EXPECT_EQ(profiles.size(), 0);
742         std::vector<int32_t> pixFormats = capability_->GetVideoSupportedPixelFormats();
743         EXPECT_EQ(pixFormats.size(), 0);
744         std::vector<int32_t> levels = capability_->GetSupportedLevelsForProfile(DEFAULT_VIDEO_AVC_PROFILE);
745         EXPECT_EQ(levels.size(), 0);
746     }
747 }
748 
749 /**
750  * @tc.name: CodecList_UNSUPPORTED_MIME_002
751  * @tc.desc: CodecList use unsupprted mime
752  * @tc.type: FUNC
753  */
754 HWTEST_F(CodecListUnitTest, CodecList_UNSUPPORTED_MIME_002, TestSize.Level1)
755 {
756     capability_ = CodecListMockFactory::GetCapabilityByCategory(
757         DEFAULT_UNSUPPORTED_MIME, false, AVCodecCategory::AVCODEC_SOFTWARE);
758     if (capability_ != nullptr) {
759         Range range = capability_->GetEncoderBitrateRange();
760         EXPECT_EQ(0, range.minVal);
761         EXPECT_EQ(0, range.maxVal);
762         range = capability_->GetEncoderQualityRange();
763         EXPECT_EQ(0, range.minVal);
764         EXPECT_EQ(0, range.maxVal);
765         range = capability_->GetEncoderComplexityRange();
766         EXPECT_EQ(0, range.minVal);
767         EXPECT_EQ(0, range.maxVal);
768         range = capability_->GetAudioChannelsRange();
769         EXPECT_EQ(0, range.minVal);
770         EXPECT_EQ(0, range.maxVal);
771         range = capability_->GetVideoWidthRangeForHeight(DEFAULT_HEIGHT);
772         EXPECT_EQ(0, range.minVal);
773         EXPECT_EQ(0, range.maxVal);
774         range = capability_->GetVideoHeightRangeForWidth(DEFAULT_WIDTH);
775         EXPECT_EQ(0, range.minVal);
776         EXPECT_EQ(0, range.maxVal);
777         range = capability_->GetVideoWidthRange();
778         EXPECT_EQ(0, range.minVal);
779         EXPECT_EQ(0, range.maxVal);
780         range = capability_->GetVideoHeightRange();
781         EXPECT_EQ(0, range.minVal);
782         EXPECT_EQ(0, range.maxVal);
783         range = capability_->GetVideoFrameRateRange();
784         EXPECT_EQ(0, range.minVal);
785         EXPECT_EQ(0, range.maxVal);
786         range = capability_->GetVideoFrameRateRangeForSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);
787         EXPECT_EQ(0, range.minVal);
788         EXPECT_EQ(0, range.maxVal);
789     }
790 }
791 
792 /**
793  * @tc.name: CodecList_GetCapabilityByCategory_Vvc_001
794  * @tc.desc: CodecList GetCapabilityByCategory Vvc
795  * @tc.type: FUNC
796  */
797 HWTEST_F(CodecListUnitTest, CodecList_GetCapabilityByCategory_Vvc_001, TestSize.Level1)
798 {
799     if (!access("/system/lib64/media/", 0)) {
800         capability_ = CodecListMockFactory::GetCapability(DEFAULT_VIDEO_VVC_MIME, false);
801         if (capability_ != nullptr && capability_->IsHardware()) {
802             AVCodecCategory category = AVCodecCategory::AVCODEC_HARDWARE;
803             capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_VVC_MIME, false, category);
804             EXPECT_NE(nullptr, capability_);
805         }
806     }
807 }
808 
809 /**
810  * @tc.name: CodecList_IsHardware_Vvc_001
811  * @tc.desc: CodecList IsHardware Vvc
812  * @tc.type: FUNC
813  */
814 HWTEST_F(CodecListUnitTest, CodecList_IsHardware_Vvc_001, TestSize.Level1)
815 {
816     if (!access("/system/lib64/media/", 0)) {
817         // video decoder
818         AVCodecCategory category = AVCodecCategory::AVCODEC_HARDWARE;
819         capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_VVC_MIME, false, category);
820         if (capability_ != nullptr) {
821             EXPECT_TRUE(capability_->IsHardware());
822         }
823     }
824 }
825 
826 /**
827  * @tc.name: CodecList_GetName_Vvc_001
828  * @tc.desc: CodecList GetName Vvc
829  * @tc.type: FUNC
830  */
831 HWTEST_F(CodecListUnitTest, CodecList_GetName_Vvc_001, TestSize.Level1)
832 {
833     if (!access("/system/lib64/media/", 0)) {
834         for (auto it = CAPABILITY_DECODER_HARD_NAME_VVC.begin(); it != CAPABILITY_DECODER_HARD_NAME_VVC.end(); ++it) {
835             std::string mime = it->first;
836             std::string nameOfMime = it->second;
837             capability_ = CodecListMockFactory::GetCapability(mime, false);
838             if (capability_ != nullptr) {
839                 std::string codecName = capability_->GetName();
840                 EXPECT_EQ(nameOfMime, codecName) << mime << " get error name: " << codecName << std::endl;
841             }
842         }
843     }
844 }
845 
846 /**
847  * @tc.name: CodecList_GetMaxSupportedInstances_Vvc_001
848  * @tc.desc: CodecList GetMaxSupportedInstances Vvc
849  * @tc.type: FUNC
850  */
851 HWTEST_F(CodecListUnitTest, CodecList_GetMaxSupportedInstances_Vvc_001, TestSize.Level1)
852 {
853     if (!access("/system/lib64/media/", 0)) {
854         // video decoder
855         AVCodecCategory category = AVCodecCategory::AVCODEC_HARDWARE;
856         capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_VVC_MIME, false, category);
857         if (capability_ != nullptr) {
858             EXPECT_EQ(MAX_SURPPORT_VCODEC_VVC, capability_->GetMaxSupportedInstances());
859         }
860     }
861 }
862 
863 /**
864  * @tc.name: CodecList_GetVideoWidthAlignment_Vvc_001
865  * @tc.desc: CodecList GetVideoWidthAlignment Vvc
866  * @tc.type: FUNC
867  */
868 HWTEST_F(CodecListUnitTest, CodecList_GetVideoWidthAlignment_Vvc_001, TestSize.Level1)
869 {
870     if (!access("/system/lib64/media/", 0)) {
871         // video decoder
872         AVCodecCategory category = AVCodecCategory::AVCODEC_HARDWARE;
873         capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_VVC_MIME, false, category);
874         if (capability_ != nullptr) {
875             int32_t widthAlignment = capability_->GetVideoWidthAlignment();
876             EXPECT_EQ(DEFAULT_WIDTH_ALIGNMENT, widthAlignment);
877         }
878     }
879 }
880 
881 /**
882  * @tc.name: CodecList_GetVideoHeightAlignment_Vvc_001
883  * @tc.desc: CodecList GetVideoHeightAlignment Vvc
884  * @tc.type: FUNC
885  */
886 HWTEST_F(CodecListUnitTest, CodecList_GetVideoHeightAlignment_Vvc_001, TestSize.Level1)
887 {
888     if (!access("/system/lib64/media/", 0)) {
889         // video decoder
890         AVCodecCategory category = AVCodecCategory::AVCODEC_HARDWARE;
891         capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_VVC_MIME, false, category);
892         if (capability_ != nullptr) {
893             int32_t heightAlignment = capability_->GetVideoHeightAlignment();
894             EXPECT_EQ(DEFAULT_HEIGHT_ALIGNMENT, heightAlignment);
895         }
896     }
897 }
898 
899 /**
900  * @tc.name: CodecList_GetVideoHeightRangeForWidth_Vvc_001
901  * @tc.desc: CodecList GetVideoHeightRangeForWidth Vvc
902  * @tc.type: FUNC
903  */
904 HWTEST_F(CodecListUnitTest, CodecList_GetVideoHeightRangeForWidth_Vvc_001, TestSize.Level1)
905 {
906     if (!access("/system/lib64/media/", 0)) {
907         // video decoder
908         AVCodecCategory category = AVCodecCategory::AVCODEC_HARDWARE;
909         capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_VVC_MIME, false, category);
910         if (capability_ != nullptr) {
911             Range widthRange = capability_->GetVideoHeightRangeForWidth(DEFAULT_WIDTH_VVC);
912             EXPECT_EQ(DEFAULT_HEIGHT_RANGE_OF_WIDTH_VVC.minVal, widthRange.minVal);
913             EXPECT_EQ(DEFAULT_HEIGHT_RANGE_OF_WIDTH_VVC.maxVal, widthRange.maxVal);
914         }
915     }
916 }
917 
918 /**
919  * @tc.name: CodecList_GetVideoWidthRangeForHeight_Vvc_001
920  * @tc.desc: CodecList GetVideoWidthRangeForHeight Vvc
921  * @tc.type: FUNC
922  */
923 HWTEST_F(CodecListUnitTest, CodecList_GetVideoWidthRangeForHeight_Vvc_001, TestSize.Level1)
924 {
925     if (!access("/system/lib64/media/", 0)) {
926         // video decoder
927         AVCodecCategory category = AVCodecCategory::AVCODEC_HARDWARE;
928         capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_VVC_MIME, false, category);
929         if (capability_ != nullptr) {
930             Range heightRange = capability_->GetVideoWidthRangeForHeight(DEFAULT_HEIGHT_VVC);
931             EXPECT_EQ(DEFAULT_WIDTH_RANGE_OF_HEIGHT_VVC.minVal, heightRange.minVal);
932             EXPECT_EQ(DEFAULT_WIDTH_RANGE_OF_HEIGHT_VVC.maxVal, heightRange.maxVal);
933         }
934     }
935 }
936 
937 /**
938  * @tc.name: CodecList_GetVideoWidthRange_Vvc_001
939  * @tc.desc: CodecList GetVideoWidthRange Vvc
940  * @tc.type: FUNC
941  */
942 HWTEST_F(CodecListUnitTest, CodecList_GetVideoWidthRange_Vvc_001, TestSize.Level1)
943 {
944     if (!access("/system/lib64/media/", 0)) {
945         // video decoder
946         AVCodecCategory category = AVCodecCategory::AVCODEC_HARDWARE;
947         capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_VVC_MIME, false, category);
948         if (capability_ != nullptr) {
949             Range widthRange = capability_->GetVideoWidthRange();
950             EXPECT_EQ(DEFAULT_WIDTH_RANGE_VVC.minVal, widthRange.minVal);
951             EXPECT_EQ(DEFAULT_WIDTH_RANGE_VVC.maxVal, widthRange.maxVal);
952         }
953     }
954 }
955 
956 /**
957  * @tc.name: CodecList_GetVideoHeightRange_Vvc_001
958  * @tc.desc: CodecList GetVideoHeightRange Vvc
959  * @tc.type: FUNC
960  */
961 HWTEST_F(CodecListUnitTest, CodecList_GetVideoHeightRange_Vvc_001, TestSize.Level1)
962 {
963     if (!access("/system/lib64/media/", 0)) {
964         // video decoder
965         AVCodecCategory category = AVCodecCategory::AVCODEC_HARDWARE;
966         capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_VVC_MIME, false, category);
967         if (capability_ != nullptr) {
968             Range heightRange = capability_->GetVideoHeightRange();
969             EXPECT_EQ(DEFAULT_HEIGHT_RANGE_VVC.minVal, heightRange.minVal);
970             EXPECT_EQ(DEFAULT_HEIGHT_RANGE_VVC.maxVal, heightRange.maxVal);
971         }
972     }
973 }
974 
975 /**
976  * @tc.name: CodecList_IsVideoSizeSupported_Vvc_001
977  * @tc.desc: CodecList IsVideoSizeSupported Vvc
978  * @tc.type: FUNC
979  */
980 HWTEST_F(CodecListUnitTest, CodecList_IsVideoSizeSupported_Vvc_001, TestSize.Level1)
981 {
982     if (!access("/system/lib64/media/", 0)) {
983         // video decoder
984         AVCodecCategory category = AVCodecCategory::AVCODEC_HARDWARE;
985         capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_VVC_MIME, false, category);
986         if (capability_ != nullptr) {
987             int32_t wmin = DEFAULT_WIDTH_RANGE_VVC.minVal;
988             int32_t wmax = DEFAULT_WIDTH_RANGE_VVC.maxVal;
989             int32_t hmin = DEFAULT_HEIGHT_RANGE_VVC.minVal;
990             int32_t hmax = DEFAULT_HEIGHT_RANGE_VVC.maxVal;
991             // case 1 - 13, postive param
992             EXPECT_TRUE(capability_->IsVideoSizeSupported(DEFAULT_WIDTH_VVC, DEFAULT_HEIGHT_VVC))
993                 << "width:" << DEFAULT_WIDTH_VVC << "height:" << DEFAULT_HEIGHT_VVC << std::endl;
994             EXPECT_TRUE(capability_->IsVideoSizeSupported(wmin, DEFAULT_HEIGHT_VVC))
995                 << "width:" << wmin << "height:" << DEFAULT_HEIGHT_VVC << std::endl;
996             EXPECT_TRUE(capability_->IsVideoSizeSupported(wmin + 2, DEFAULT_HEIGHT_VVC))
997                 << "width:" << wmin + 2 << "height:" << DEFAULT_HEIGHT_VVC << std::endl;
998             EXPECT_TRUE(capability_->IsVideoSizeSupported(wmin + 2, hmax))
999                 << "width:" << wmin + 2 << "height:" << hmax << std::endl;
1000             EXPECT_TRUE(capability_->IsVideoSizeSupported(wmin + 2, hmax - 2))
1001                 << "width:" << wmin + 2 << "height:" << hmax - 2 << std::endl;
1002             EXPECT_TRUE(capability_->IsVideoSizeSupported(wmax, DEFAULT_HEIGHT_VVC))
1003                 << "width:" << wmax << "height:" << DEFAULT_HEIGHT_VVC << std::endl;
1004             EXPECT_TRUE(capability_->IsVideoSizeSupported(wmax - 2, DEFAULT_HEIGHT_VVC))
1005                 << "width:" << wmax - 2 << "height:" << DEFAULT_HEIGHT_VVC << std::endl;
1006             EXPECT_TRUE(capability_->IsVideoSizeSupported(wmax - 2, hmin))
1007                 << "width:" << wmax - 2 << "height:" << hmin << std::endl;
1008             EXPECT_TRUE(capability_->IsVideoSizeSupported(wmax - 2, hmin + 2))
1009                 << "width:" << wmax - 2 << "height:" << hmin + 2 << std::endl;
1010             EXPECT_TRUE(capability_->IsVideoSizeSupported(DEFAULT_WIDTH_VVC, hmin))
1011                 << "width:" << DEFAULT_WIDTH_VVC << "height:" << hmin << std::endl;
1012             EXPECT_TRUE(capability_->IsVideoSizeSupported(DEFAULT_WIDTH_VVC, hmin + 2))
1013                 << "width:" << DEFAULT_WIDTH_VVC << "height:" << hmin + 2 << std::endl;
1014             // Swap case
1015             EXPECT_TRUE(capability_->IsVideoSizeSupported(DEFAULT_HEIGHT_VVC, hmax))
1016                 << "width:" << DEFAULT_HEIGHT_VVC << "height:" << hmax << std::endl;
1017             EXPECT_TRUE(capability_->IsVideoSizeSupported(DEFAULT_HEIGHT_VVC, hmax - 2))
1018                 << "width:" << DEFAULT_HEIGHT_VVC << "height:" << hmax - 2 << std::endl;
1019         }
1020     }
1021 }
1022 
1023 /**
1024  * @tc.name: CodecList_IsVideoSizeSupported_Vvc_002
1025  * @tc.desc: CodecList IsVideoSizeSupported Vvc
1026  * @tc.type: FUNC
1027  */
1028 HWTEST_F(CodecListUnitTest, CodecList_IsVideoSizeSupported_Vvc_002, TestSize.Level1)
1029 {
1030     if (!access("/system/lib64/media/", 0)) {
1031         // video decoder
1032         AVCodecCategory category = AVCodecCategory::AVCODEC_HARDWARE;
1033         capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_VVC_MIME, false, category);
1034         if (capability_ != nullptr) {
1035             int32_t wmin = DEFAULT_WIDTH_RANGE_VVC.minVal;
1036             int32_t wmax = DEFAULT_WIDTH_RANGE_VVC.maxVal;
1037             int32_t hmin = DEFAULT_HEIGHT_RANGE_VVC.minVal;
1038             int32_t hmax = DEFAULT_HEIGHT_RANGE_VVC.maxVal;
1039             // case 1 - 10, negative param
1040             EXPECT_FALSE(capability_->IsVideoSizeSupported(wmax + 2, hmin))
1041                 << "width:" << wmax + 2 << "height:" << hmin << std::endl;
1042             EXPECT_FALSE(capability_->IsVideoSizeSupported(wmin - 2, hmin))
1043                 << "width:" << wmin - 2 << "height:" << hmin << std::endl;
1044             EXPECT_FALSE(capability_->IsVideoSizeSupported(wmax + 2, hmax))
1045                 << "width:" << wmax + 2 << "height:" << hmax << std::endl;
1046             EXPECT_FALSE(capability_->IsVideoSizeSupported(wmin - 2, hmax))
1047                 << "width:" << wmin - 2 << "height:" << hmax << std::endl;
1048 
1049             EXPECT_FALSE(capability_->IsVideoSizeSupported(wmin, hmin - 2))
1050                 << "width:" << wmin << "height:" << hmin - 2 << std::endl;
1051             EXPECT_FALSE(capability_->IsVideoSizeSupported(wmin, hmax + 2))
1052                 << "width:" << wmin << "height:" << hmax + 2 << std::endl;
1053             EXPECT_FALSE(capability_->IsVideoSizeSupported(wmax, hmin - 2))
1054                 << "width:" << wmax << "height:" << hmin - 2 << std::endl;
1055             EXPECT_FALSE(capability_->IsVideoSizeSupported(wmax, hmax + 2))
1056                 << "width:" << wmax << "height:" << hmax + 2 << std::endl;
1057 
1058             EXPECT_FALSE(capability_->IsVideoSizeSupported(wmax + 1, DEFAULT_HEIGHT_VVC))
1059                 << "width:" << wmax + 1 << "height:" << DEFAULT_HEIGHT_VVC << std::endl;
1060             // Swap case
1061             EXPECT_FALSE(capability_->IsVideoSizeSupported(DEFAULT_HEIGHT_VVC, hmax + 1))
1062                 << "width:" << DEFAULT_HEIGHT_VVC << "height:" << hmax + 1 << std::endl;
1063         }
1064     }
1065 }
1066 
1067 /**
1068  * @tc.name: CodecList_GetVideoFrameRateRange_Vvc_001
1069  * @tc.desc: CodecList GetVideoFrameRateRange Vvc
1070  * @tc.type: FUNC
1071  */
1072 HWTEST_F(CodecListUnitTest, CodecList_GetVideoFrameRateRange_Vvc_001, TestSize.Level1)
1073 {
1074     if (!access("/system/lib64/media/", 0)) {
1075         // video decoder
1076         AVCodecCategory category = AVCodecCategory::AVCODEC_HARDWARE;
1077         capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_VVC_MIME, false, category);
1078         if (capability_ != nullptr) {
1079             Range framerateRange = capability_->GetVideoFrameRateRange();
1080             EXPECT_EQ(DEFAULT_FRAMERATE_RANGE_VVC.minVal, framerateRange.minVal);
1081             EXPECT_EQ(DEFAULT_FRAMERATE_RANGE_VVC.maxVal, framerateRange.maxVal);
1082         }
1083     }
1084 }
1085 
1086 /**
1087  * @tc.name: CodecList_AreVideoSizeAndFrameRateSupported_Vvc_001
1088  * @tc.desc: CodecList AreVideoSizeAndFrameRateSupported Vvc
1089  * @tc.type: FUNC
1090  */
1091 HWTEST_F(CodecListUnitTest, CodecList_AreVideoSizeAndFrameRateSupported_Vvc_001, TestSize.Level1)
1092 {
1093     if (!access("/system/lib64/media/", 0)) {
1094         // video decoder
1095         AVCodecCategory category = AVCodecCategory::AVCODEC_HARDWARE;
1096         capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_VVC_MIME, false, category);
1097         if (capability_ != nullptr) {
1098             int32_t minVal = DEFAULT_FRAMERATE_RANGE_VVC.minVal;
1099             int32_t maxVal = DEFAULT_FRAMERATE_RANGE_VVC.maxVal;
1100             // case 1 - 3, positive param
1101             EXPECT_TRUE(capability_->AreVideoSizeAndFrameRateSupported(DEFAULT_WIDTH, DEFAULT_HEIGHT, minVal + 1))
1102                 << "width:" << DEFAULT_WIDTH << "height:" << DEFAULT_HEIGHT << "framerate: " << minVal + 1 << std::endl;
1103             EXPECT_TRUE(capability_->AreVideoSizeAndFrameRateSupported(128, 128, maxVal))
1104                 << "width:" << DEFAULT_WIDTH << "height:" << DEFAULT_HEIGHT << "framerate: " << maxVal << std::endl;
1105             EXPECT_TRUE(capability_->AreVideoSizeAndFrameRateSupported(128, 128, maxVal - 1))
1106                 << "width:" << DEFAULT_WIDTH << "height:" << DEFAULT_HEIGHT << "framerate: " << maxVal - 1 << std::endl;
1107         }
1108     }
1109 }
1110 
1111 /**
1112  * @tc.name: CodecList_AreVideoSizeAndFrameRateSupported_Vvc_002
1113  * @tc.desc: CodecList AreVideoSizeAndFrameRateSupported Vvc
1114  * @tc.type: FUNC
1115  */
1116 HWTEST_F(CodecListUnitTest, CodecList_AreVideoSizeAndFrameRateSupported_Vvc_002, TestSize.Level1)
1117 {
1118     if (!access("/system/lib64/media/", 0)) {
1119         // video decoder
1120         AVCodecCategory category = AVCodecCategory::AVCODEC_HARDWARE;
1121         capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_VVC_MIME, false, category);
1122         if (capability_ != nullptr) {
1123             int32_t minVal = DEFAULT_FRAMERATE_RANGE_VVC.minVal;
1124             int32_t maxVal = DEFAULT_FRAMERATE_RANGE_VVC.maxVal;
1125             // case 1 - 10, negative param
1126             EXPECT_FALSE(capability_->AreVideoSizeAndFrameRateSupported(DEFAULT_WIDTH, DEFAULT_HEIGHT, minVal))
1127                 << "width:" << DEFAULT_WIDTH << "height:" << DEFAULT_HEIGHT << "framerate: " << minVal << std::endl;
1128             EXPECT_FALSE(capability_->AreVideoSizeAndFrameRateSupported(DEFAULT_WIDTH, DEFAULT_HEIGHT, minVal - 1))
1129                 << "width:" << DEFAULT_WIDTH << "height:" << DEFAULT_HEIGHT << "framerate: " << minVal - 1 << std::endl;
1130             EXPECT_FALSE(capability_->AreVideoSizeAndFrameRateSupported(DEFAULT_WIDTH, DEFAULT_HEIGHT, maxVal + 1))
1131                 << "width:" << DEFAULT_WIDTH << "height:" << DEFAULT_HEIGHT << "framerate: " << maxVal + 1 << std::endl;
1132             EXPECT_FALSE(capability_->AreVideoSizeAndFrameRateSupported(DEFAULT_WIDTH, DEFAULT_HEIGHT, ERROR_FRAMERATE))
1133                 << "width:" << DEFAULT_WIDTH << "height:" << DEFAULT_HEIGHT << "framerate:" << ERROR_FRAMERATE
1134                 << std::endl;
1135             EXPECT_FALSE(capability_->AreVideoSizeAndFrameRateSupported(DEFAULT_WIDTH, ERROR_HEIGHT, DEFAULT_FRAMERATE))
1136                 << "width:" << DEFAULT_WIDTH << "height:" << ERROR_HEIGHT << "framerate:" << DEFAULT_FRAMERATE
1137                 << std::endl;
1138             EXPECT_FALSE(capability_->AreVideoSizeAndFrameRateSupported(DEFAULT_WIDTH, ERROR_HEIGHT, ERROR_FRAMERATE))
1139                 << "width:" << DEFAULT_WIDTH << "height:" << ERROR_HEIGHT << "framerate: " << ERROR_FRAMERATE
1140                 << std::endl;
1141             EXPECT_FALSE(capability_->AreVideoSizeAndFrameRateSupported(ERROR_WIDTH, DEFAULT_HEIGHT, DEFAULT_FRAMERATE))
1142                 << "width:" << ERROR_WIDTH << "height:" << DEFAULT_HEIGHT << "framerate:" << DEFAULT_FRAMERATE
1143                 << std::endl;
1144             EXPECT_FALSE(capability_->AreVideoSizeAndFrameRateSupported(ERROR_WIDTH, DEFAULT_HEIGHT, ERROR_FRAMERATE))
1145                 << "width:" << ERROR_WIDTH << "height:" << DEFAULT_HEIGHT << "framerate: " << ERROR_FRAMERATE
1146                 << std::endl;
1147             EXPECT_FALSE(capability_->AreVideoSizeAndFrameRateSupported(ERROR_WIDTH, ERROR_HEIGHT, DEFAULT_FRAMERATE))
1148                 << "width:" << ERROR_WIDTH << "height:" << ERROR_HEIGHT << "framerate: " << DEFAULT_FRAMERATE
1149                 << std::endl;
1150             EXPECT_FALSE(capability_->AreVideoSizeAndFrameRateSupported(ERROR_WIDTH, ERROR_HEIGHT, ERROR_FRAMERATE))
1151                 << "width:" << ERROR_WIDTH << "height:" << ERROR_HEIGHT << "framerate: " << ERROR_FRAMERATE
1152                 << std::endl;
1153         }
1154     }
1155 }
1156 
1157 /**
1158  * @tc.name: CodecList_GetVideoFrameRateRangeForSize_Vvc_001
1159  * @tc.desc: CodecList GetVideoFrameRateRangeForSize Vvc
1160  * @tc.type: FUNC
1161  */
1162 HWTEST_F(CodecListUnitTest, CodecList_GetVideoFrameRateRangeForSize_Vvc_001, TestSize.Level1)
1163 {
1164     if (!access("/system/lib64/media/", 0)) {
1165         // video decoder
1166         AVCodecCategory category = AVCodecCategory::AVCODEC_HARDWARE;
1167         capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_VVC_MIME, false, category);
1168         if (capability_ != nullptr) {
1169             Range framerateRange = capability_->GetVideoFrameRateRangeForSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);
1170             EXPECT_EQ(1, framerateRange.minVal);
1171             EXPECT_EQ(120, framerateRange.maxVal);
1172 
1173             framerateRange = capability_->GetVideoFrameRateRangeForSize(DEFAULT_WIDTH_VVC, DEFAULT_HEIGHT_VVC);
1174             EXPECT_EQ(1, framerateRange.minVal);
1175             EXPECT_EQ(30, framerateRange.maxVal);
1176         }
1177     }
1178 }
1179 
1180 /**
1181  * @tc.name: CodecList_GetVideoFrameRateRangeForSize_Vvc_002
1182  * @tc.desc: CodecList GetVideoFrameRateRangeForSize Vvc
1183  * @tc.type: FUNC
1184  */
1185 HWTEST_F(CodecListUnitTest, CodecList_GetVideoFrameRateRangeForSize_Vvc_002, TestSize.Level1)
1186 {
1187     if (!access("/system/lib64/media/", 0)) {
1188         // video decoder
1189         AVCodecCategory category = AVCodecCategory::AVCODEC_HARDWARE;
1190         capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_VVC_MIME, false, category);
1191         if (capability_ != nullptr) {
1192             int32_t wmax = DEFAULT_WIDTH_RANGE_VVC.maxVal;
1193             int32_t hmax = DEFAULT_HEIGHT_RANGE_VVC.maxVal;
1194             Range framerateRange = capability_->GetVideoFrameRateRangeForSize(0, 0);
1195             EXPECT_EQ(0, framerateRange.minVal);
1196             EXPECT_EQ(0, framerateRange.maxVal);
1197 
1198             framerateRange = capability_->GetVideoFrameRateRangeForSize(wmax + 2, hmax + 2);
1199             EXPECT_EQ(0, framerateRange.minVal);
1200             EXPECT_EQ(0, framerateRange.maxVal);
1201 
1202             framerateRange = capability_->GetVideoFrameRateRangeForSize(wmax - 1, hmax - 1);
1203             EXPECT_EQ(0, framerateRange.minVal);
1204             EXPECT_EQ(0, framerateRange.maxVal);
1205 
1206             framerateRange = capability_->GetVideoFrameRateRangeForSize(-2, -2);
1207             EXPECT_EQ(0, framerateRange.minVal);
1208             EXPECT_EQ(0, framerateRange.maxVal);
1209         }
1210     }
1211 }
1212 
1213 /**
1214  * @tc.name: CodecList_GetVideoSupportedPixelFormats_Vvc_001
1215  * @tc.desc: CodecList GetVideoSupportedPixelFormats Vvc
1216  * @tc.type: FUNC
1217  */
1218 HWTEST_F(CodecListUnitTest, CodecList_GetVideoSupportedPixelFormats_Vvc_001, TestSize.Level1)
1219 {
1220     if (!access("/system/lib64/media/", 0)) {
1221         // video decoder
1222         AVCodecCategory category = AVCodecCategory::AVCODEC_HARDWARE;
1223         capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_VVC_MIME, false, category);
1224         if (capability_ != nullptr) {
1225             std::vector<int32_t> pixFormats = capability_->GetVideoSupportedPixelFormats();
1226             EXPECT_EQ(DEFAULT_VIDEO_VVC_PIXFORMATS, pixFormats);
1227         }
1228     }
1229 }
1230 
1231 /**
1232  * @tc.name: CodecList_GetSupportedProfiles_Vvc_001
1233  * @tc.desc: CodecList GetSupportedProfiles Vvc
1234  * @tc.type: FUNC
1235  */
1236 HWTEST_F(CodecListUnitTest, CodecList_GetSupportedProfiles_Vvc_001, TestSize.Level1)
1237 {
1238     if (!access("/system/lib64/media/", 0)) {
1239         // video decoder
1240         AVCodecCategory category = AVCodecCategory::AVCODEC_HARDWARE;
1241         capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_VVC_MIME, false, category);
1242         if (capability_ != nullptr) {
1243             std::vector<int32_t> profiles = capability_->GetSupportedProfiles();
1244             EXPECT_EQ(DEFAULT_VIDEO_VVC_PROFILES, profiles);
1245         }
1246     }
1247 }
1248 
1249 /**
1250  * @tc.name: CodecList_GetSupportedLevelsForProfile_Vvc_001
1251  * @tc.desc: CodecList GetSupportedLevelsForProfile Vvc
1252  * @tc.type: FUNC
1253  */
1254 HWTEST_F(CodecListUnitTest, CodecList_GetSupportedLevelsForProfile_Vvc_001, TestSize.Level1)
1255 {
1256     if (!access("/system/lib64/media/", 0)) {
1257         // video decoder
1258         AVCodecCategory category = AVCodecCategory::AVCODEC_HARDWARE;
1259         capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_VVC_MIME, false, category);
1260         if (capability_ != nullptr) {
1261             std::vector<int32_t> levels;
1262             for (auto it : DEFAULT_VIDEO_VVC_PROFILES) {
1263                 levels = capability_->GetSupportedLevelsForProfile(it);
1264                 EXPECT_EQ(DEFAULT_VIDEO_VVC_LEVELS, levels);
1265             }
1266         }
1267     }
1268 }
1269 
1270 /**
1271  * @tc.name: CodecList_AreProfileAndLevelSupported_Vvc_001
1272  * @tc.desc: CodecList AreProfileAndLevelSupported Vvc
1273  * @tc.type: FUNC
1274  */
1275 HWTEST_F(CodecListUnitTest, CodecList_AreProfileAndLevelSupported_Vvc_001, TestSize.Level1)
1276 {
1277     if (!access("/system/lib64/media/", 0)) {
1278         // video decoder
1279         AVCodecCategory category = AVCodecCategory::AVCODEC_HARDWARE;
1280         capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_VVC_MIME, false, category);
1281         if (capability_ != nullptr) {
1282             // case 1 - 16, postive param
1283             for (auto it : DEFAULT_VIDEO_VVC_LEVELS) {
1284                 EXPECT_TRUE(capability_->AreProfileAndLevelSupported(DEFAULT_VIDEO_VVC_PROFILE, it));
1285             }
1286         }
1287     }
1288 }
1289 
1290 /**
1291  * @tc.name: CodecList_AreProfileAndLevelSupported_Vvc_002
1292  * @tc.desc: CodecList AreProfileAndLevelSupported Vvc
1293  * @tc.type: FUNC
1294  */
1295 HWTEST_F(CodecListUnitTest, CodecList_AreProfileAndLevelSupported_Vvc_002, TestSize.Level1)
1296 {
1297     if (!access("/system/lib64/media/", 0)) {
1298         // video decoder
1299         AVCodecCategory category = AVCodecCategory::AVCODEC_HARDWARE;
1300         capability_ = CodecListMockFactory::GetCapabilityByCategory(DEFAULT_VIDEO_VVC_MIME, false, category);
1301         if (capability_ != nullptr) {
1302             // case 1, negative param
1303             EXPECT_FALSE(capability_->AreProfileAndLevelSupported(DEFAULT_VIDEO_VVC_PROFILE, ERROR_LEVEL));
1304             // case 2, negative param
1305             EXPECT_FALSE(capability_->AreProfileAndLevelSupported(ERROR_VIDEO_VVC_PROFILE, DEFAULT_VIDEO_VVC_LEVEL));
1306             // case 3, negative param
1307             EXPECT_FALSE(capability_->AreProfileAndLevelSupported(ERROR_VIDEO_VVC_PROFILE, ERROR_LEVEL));
1308         }
1309     }
1310 }