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 <vector>
17 #include <queue>
18 #include <mutex>
19 #include <gtest/gtest.h>
20 #include <fstream>
21 #include "decoder/audio_ffmpeg_aac_decoder_plugin.h"
22 #include "decoder/audio_ffmpeg_flac_decoder_plugin.h"
23 #include "decoder/audio_ffmpeg_mp3_decoder_plugin.h"
24 #include "decoder/audio_opus_decoder_plugin.h"
25 #include "audio_codec_adapter.h"
26 #include "meta/format.h"
27 #include "avcodec_codec_name.h"
28 #include "avcodec_common.h"
29 #include "avcodec_errors.h"
30 #include "media_description.h"
31 
32 using namespace std;
33 using namespace testing::ext;
34 using namespace OHOS::MediaAVCodec;
35 
36 namespace {
37 const string CODEC_MP3_NAME = std::string(AVCodecCodecName::AUDIO_DECODER_MP3_NAME);
38 const string CODEC_FLAC_NAME = std::string(AVCodecCodecName::AUDIO_DECODER_FLAC_NAME);
39 const string CODEC_AAC_NAME = std::string(AVCodecCodecName::AUDIO_DECODER_AAC_NAME);
40 const string CODEC_OPUS_NAME = std::string(AVCodecCodecName::AUDIO_DECODER_OPUS_NAME);
41 constexpr uint32_t MAX_CHANNEL_COUNT = 2;
42 constexpr uint32_t INVALID_CHANNEL_COUNT = 3;
43 constexpr uint32_t DEFAULT_SAMPLE_RATE = 8000;
44 constexpr uint32_t INVALID_SAMPLE_RATE = 9999990;
45 constexpr uint32_t DEFAULT_BITRATE = 128000;
46 constexpr uint32_t DEFAULT_WIDTH = 0;
47 constexpr uint32_t DEFAULT_AAC_TYPE = 1;
48 constexpr uint32_t DEFAULT_AAC_LATM_TYPE = 0;
49 const string OPUS_SO_FILE_PATH = std::string(AV_CODEC_PATH) + "/libav_codec_ext_base.z.so";
50 } // namespace
51 
52 namespace OHOS {
53 namespace MediaAVCodec {
54 class ADecSignal {
55 public:
56     std::mutex inMutex_;
57     std::mutex outMutex_;
58     std::condition_variable inCond_;
59     std::condition_variable outCond_;
60     std::queue<int32_t> inIdxQueue_;
61     std::queue<int32_t> outIdxQueue_;
62     std::queue<std::shared_ptr<AVSharedMemory>> inBufferQueue_;
63     std::queue<std::shared_ptr<AVSharedMemory>> outBufferQueue_;
64     std::queue<AVCodecBufferInfo> infoQueue_;
65     std::queue<AVCodecBufferFlag> flagQueue_;
66 };
67 
68 class BufferCallback : public AVCodecCallback {
69 public:
BufferCallback(ADecSignal * userData)70     explicit BufferCallback(ADecSignal *userData) : userData_(userData) {}
71     virtual ~BufferCallback() = default;
72     ADecSignal *userData_;
73     void OnError(AVCodecErrorType errorType, int32_t errorCode) override;
74     void OnOutputFormatChanged(const Format &format) override;
75     void OnInputBufferAvailable(uint32_t index, std::shared_ptr<AVSharedMemory> buffer) override;
76     void OnOutputBufferAvailable(uint32_t index, AVCodecBufferInfo info, AVCodecBufferFlag flag,
77                                  std::shared_ptr<AVSharedMemory> buffer) override;
78 };
79 
OnError(AVCodecErrorType errorType,int32_t errorCode)80 void BufferCallback::OnError(AVCodecErrorType errorType, int32_t errorCode)
81 {
82     (void)errorType;
83     cout << "Error errorCode=" << errorCode << endl;
84 }
85 
OnOutputFormatChanged(const Format & format)86 void BufferCallback::OnOutputFormatChanged(const Format &format)
87 {
88     (void)format;
89     cout << "Format Changed" << endl;
90 }
91 
OnInputBufferAvailable(uint32_t index,std::shared_ptr<AVSharedMemory> buffer)92 void BufferCallback::OnInputBufferAvailable(uint32_t index, std::shared_ptr<AVSharedMemory> buffer)
93 {
94     unique_lock<mutex> lock(userData_->inMutex_);
95     userData_->inIdxQueue_.push(index);
96     userData_->inBufferQueue_.push(buffer);
97     userData_->inCond_.notify_all();
98 }
99 
OnOutputBufferAvailable(uint32_t index,AVCodecBufferInfo info,AVCodecBufferFlag flag,std::shared_ptr<AVSharedMemory> buffer)100 void BufferCallback::OnOutputBufferAvailable(uint32_t index, AVCodecBufferInfo info, AVCodecBufferFlag flag,
101                                              std::shared_ptr<AVSharedMemory> buffer)
102 {
103     unique_lock<mutex> lock(userData_->outMutex_);
104     userData_->outIdxQueue_.push(index);
105     userData_->infoQueue_.push(info);
106     userData_->flagQueue_.push(flag);
107     userData_->outBufferQueue_.push(buffer);
108     userData_->outCond_.notify_all();
109     (void)flag;
110 }
111 
112 class AudioCodeDecoderUnitTest : public testing::Test {
113 public:
114     static void SetUpTestCase(void);
115     static void TearDownTestCase(void);
116     AudioCodeDecoderUnitTest() = default;
117     ~AudioCodeDecoderUnitTest();
118     void SetUp();
119     void TearDown();
120     int32_t ProceMp3Func();
121     int32_t ProceFlacFunc();
122     int32_t ProceAacFunc();
123     int32_t ProceOpusFunc();
124     int32_t CreateMp3CodecFunc();
125     int32_t CreateFlacCodecFunc();
126     int32_t CreateAacCodecFunc();
127     int32_t CreateOpusCodecFunc();
128     int32_t CheckSoFunc();
129 
130 protected:
131     std::unique_ptr<std::ifstream> soFile_;
132     int32_t index_;
133     int64_t timeStamp_ { 0 };
134 
135     ADecSignal *signal_;
136 
137     FILE *inFile_ { nullptr };
138     FILE *dumpFd_ { nullptr };
139 
140     OHOS::MediaAVCodec::Format format_;
141     std::shared_ptr<OHOS::MediaAVCodec::CodecBase> adec_ { nullptr };
142 };
143 
~AudioCodeDecoderUnitTest()144 AudioCodeDecoderUnitTest::~AudioCodeDecoderUnitTest()
145 {
146     cout << "destroyed.";
147     if (adec_ != nullptr) {
148         adec_->Stop();
149         adec_->Release();
150         adec_ = nullptr;
151     }
152 }
153 
SetUpTestCase(void)154 void AudioCodeDecoderUnitTest::SetUpTestCase(void)
155 {
156     AudioFFMpegMp3DecoderPlugin::avRegister();
157     AudioFFMpegFlacDecoderPlugin::avRegister();
158     AudioFFMpegAacDecoderPlugin::avRegister();
159     AudioOpusDecoderPlugin::avRegister();
160     cout << "[SetUpTestCase]: " << endl;
161 }
162 
TearDownTestCase(void)163 void AudioCodeDecoderUnitTest::TearDownTestCase(void)
164 {
165     cout << "[TearDownTestCase]: " << endl;
166 }
167 
SetUp(void)168 void AudioCodeDecoderUnitTest::SetUp(void)
169 {
170     cout << "[SetUp]: SetUp!!!" << endl;
171 }
172 
TearDown(void)173 void AudioCodeDecoderUnitTest::TearDown(void)
174 {
175     if (adec_) {
176         adec_->Stop();
177         adec_->Release();
178     }
179     cout << "[TearDown]: over!!!" << endl;
180 }
181 
CreateMp3CodecFunc(void)182 int32_t AudioCodeDecoderUnitTest::CreateMp3CodecFunc(void)
183 {
184     adec_ = std::make_shared<OHOS::MediaAVCodec::AudioCodecAdapter>(CODEC_MP3_NAME);
185 
186     signal_ = new ADecSignal();
187     adec_->SetCallback(std::shared_ptr<AVCodecCallback>(std::make_shared<BufferCallback>(signal_)));
188     Media::Meta callerInfo;
189     int32_t ret = adec_->Init(callerInfo);
190     sleep(1);
191     return ret;
192 }
193 
CreateFlacCodecFunc(void)194 int32_t AudioCodeDecoderUnitTest::CreateFlacCodecFunc(void)
195 {
196     adec_ = std::make_shared<OHOS::MediaAVCodec::AudioCodecAdapter>(CODEC_FLAC_NAME);
197 
198     signal_ = new ADecSignal();
199     adec_->SetCallback(std::shared_ptr<AVCodecCallback>(std::make_shared<BufferCallback>(signal_)));
200     Media::Meta callerInfo;
201     int32_t ret = adec_->Init(callerInfo);
202     sleep(1);
203     return ret;
204 }
205 
CreateAacCodecFunc(void)206 int32_t AudioCodeDecoderUnitTest::CreateAacCodecFunc(void)
207 {
208     adec_ = std::make_shared<OHOS::MediaAVCodec::AudioCodecAdapter>(CODEC_AAC_NAME);
209 
210     signal_ = new ADecSignal();
211     adec_->SetCallback(std::shared_ptr<AVCodecCallback>(std::make_shared<BufferCallback>(signal_)));
212     Media::Meta callerInfo;
213     int32_t ret = adec_->Init(callerInfo);
214     sleep(1);
215     return ret;
216 }
217 
CreateOpusCodecFunc(void)218 int32_t AudioCodeDecoderUnitTest::CreateOpusCodecFunc(void)
219 {
220     adec_ = std::make_shared<OHOS::MediaAVCodec::AudioCodecAdapter>(CODEC_OPUS_NAME);
221 
222     signal_ = new ADecSignal();
223     adec_->SetCallback(std::shared_ptr<AVCodecCallback>(std::make_shared<BufferCallback>(signal_)));
224     Media::Meta callerInfo;
225     int32_t ret = adec_->Init(callerInfo);
226     sleep(1);
227     return ret;
228 }
229 
CheckSoFunc()230 int32_t AudioCodeDecoderUnitTest::CheckSoFunc()
231 {
232     soFile_ = std::make_unique<std::ifstream>(OPUS_SO_FILE_PATH, std::ios::binary);
233     if (!soFile_->is_open()) {
234         cout << "Fatal: Open so file failed" << endl;
235         return false;
236     }
237     soFile_->close();
238     return true;
239 }
240 
ProceMp3Func(void)241 int32_t AudioCodeDecoderUnitTest::ProceMp3Func(void)
242 {
243     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
244     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
245     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
246 
247     if (adec_->Configure(format_) != AVCodecServiceErrCode::AVCS_ERR_OK) {
248         return AVCodecServiceErrCode::AVCS_ERR_UNKNOWN;
249     } else if (adec_->Start() != AVCodecServiceErrCode::AVCS_ERR_OK) {
250         return AVCodecServiceErrCode::AVCS_ERR_UNKNOWN;
251     }
252     return AVCodecServiceErrCode::AVCS_ERR_OK;
253 }
254 
ProceFlacFunc(void)255 int32_t AudioCodeDecoderUnitTest::ProceFlacFunc(void)
256 {
257     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
258     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
259     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
260 
261     if (adec_->Configure(format_) != AVCodecServiceErrCode::AVCS_ERR_OK) {
262         return AVCodecServiceErrCode::AVCS_ERR_UNKNOWN;
263     } else if (adec_->Start() != AVCodecServiceErrCode::AVCS_ERR_OK) {
264         return AVCodecServiceErrCode::AVCS_ERR_UNKNOWN;
265     }
266     return AVCodecServiceErrCode::AVCS_ERR_OK;
267 }
268 
ProceAacFunc(void)269 int32_t AudioCodeDecoderUnitTest::ProceAacFunc(void)
270 {
271     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
272     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
273     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
274     format_.PutIntValue(MediaDescriptionKey::MD_KEY_AAC_IS_ADTS, DEFAULT_AAC_TYPE);
275 
276     if (adec_->Configure(format_) != AVCodecServiceErrCode::AVCS_ERR_OK) {
277         return AVCodecServiceErrCode::AVCS_ERR_UNKNOWN;
278     } else if (adec_->Start() != AVCodecServiceErrCode::AVCS_ERR_OK) {
279         return AVCodecServiceErrCode::AVCS_ERR_UNKNOWN;
280     }
281     return AVCodecServiceErrCode::AVCS_ERR_OK;
282 }
283 
ProceOpusFunc(void)284 int32_t AudioCodeDecoderUnitTest::ProceOpusFunc(void)
285 {
286     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
287     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
288 
289     if (adec_->Configure(format_) != AVCodecServiceErrCode::AVCS_ERR_OK) {
290         return AVCodecServiceErrCode::AVCS_ERR_UNKNOWN;
291     } else if (adec_->Start() != AVCodecServiceErrCode::AVCS_ERR_OK) {
292         return AVCodecServiceErrCode::AVCS_ERR_UNKNOWN;
293     }
294     return AVCodecServiceErrCode::AVCS_ERR_OK;
295 }
296 
297 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Mp3_Configure_01, TestSize.Level1)
298 {
299     // lack of correct key
300     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
301 
302     format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_WIDTH);
303     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_CONFIGURE_MISMATCH_CHANNEL_COUNT, adec_->Configure(format_));
304 }
305 
306 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Mp3_Configure_02, TestSize.Level1)
307 {
308     // correct key input
309     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
310     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
311     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
312     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
313 
314     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
315 }
316 
317 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Mp3_Configure_03, TestSize.Level1)
318 {
319     // correct key input with redundancy key input
320     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
321     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
322     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
323     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
324     format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_WIDTH);
325     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
326 }
327 
328 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Mp3_Configure_04, TestSize.Level1)
329 {
330     // correct key input with wrong value type input
331     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
332     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
333     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
334     format_.PutIntValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
335     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
336 }
337 
338 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Mp3_Configure_05, TestSize.Level1)
339 {
340     // correct key input with wrong value type input
341     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
342     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, INVALID_CHANNEL_COUNT);
343     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, INVALID_SAMPLE_RATE);
344     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
345     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
346 }
347 
348 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Mp3_Configure_06, TestSize.Level1)
349 {
350     // empty format input
351     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
352     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
353 }
354 
355 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Mp3_Start_01, TestSize.Level1)
356 {
357     // correct flow 1
358     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
359     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceMp3Func());
360     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
361 }
362 
363 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Mp3_Start_02, TestSize.Level1)
364 {
365     // correct flow 2
366     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
367     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceMp3Func());
368     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
369     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Start());
370     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
371 }
372 
373 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Mp3_Start_03, TestSize.Level1)
374 {
375     // wrong flow 1
376     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
377     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Start());
378     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
379 }
380 
381 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Mp3_Start_04, TestSize.Level1)
382 {
383     // wrong flow 2
384     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
385     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceMp3Func());
386     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
387     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Start());
388     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
389 }
390 
391 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Mp3_Stop_01, TestSize.Level1)
392 {
393     // correct flow 1
394     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
395     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceMp3Func());
396     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
397 }
398 
399 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Mp3_Stop_02, TestSize.Level1)
400 {
401     // correct flow 2
402     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
403     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
404     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
405     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
406     format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_WIDTH);
407     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
408     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
409 }
410 
411 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Mp3_Flush_01, TestSize.Level1)
412 {
413     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
414     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceMp3Func());
415     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Flush());
416 }
417 
418 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Mp3_Flush_02, TestSize.Level1)
419 {
420     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
421     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceMp3Func());
422     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
423     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Flush());
424     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Release());
425     adec_ = nullptr;
426 }
427 
428 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Mp3_Reset_01, TestSize.Level1)
429 {
430     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
431     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceMp3Func());
432     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
433     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Reset());
434 }
435 
436 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Mp3_Reset_02, TestSize.Level1)
437 {
438     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
439     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
440     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
441     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
442     format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_WIDTH);
443     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
444     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Reset());
445 }
446 
447 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Mp3_Reset_03, TestSize.Level1)
448 {
449     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
450     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceMp3Func());
451     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Reset());
452 }
453 
454 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Mp3_Release_01, TestSize.Level1)
455 {
456     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
457     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceMp3Func());
458     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
459     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Release());
460     adec_ = nullptr;
461 }
462 
463 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Mp3_Release_02, TestSize.Level1)
464 {
465     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
466     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
467     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
468     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
469     format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_WIDTH);
470     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
471     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Release());
472     adec_ = nullptr;
473 }
474 
475 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Mp3_Release_03, TestSize.Level1)
476 {
477     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
478     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceMp3Func());
479     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Release());
480     adec_ = nullptr;
481 }
482 
483 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Mp3_NotifyEos_01, TestSize.Level1)
484 {
485     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
486     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceMp3Func());
487     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
488     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->NotifyEos());
489 }
490 
491 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Mp3_SetParameter_01, TestSize.Level1)
492 {
493     // 尚未实现
494     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
495     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
496     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
497     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
498     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_INVALID_STATE, adec_->SetParameter(format_));
499 }
500 
501 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Mp3_GetOutputFormat_01, TestSize.Level1)
502 {
503     // 尚未实现
504     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
505     EXPECT_EQ(AVCS_ERR_OK, ProceMp3Func());
506     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->GetOutputFormat(format_));
507     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
508 }
509 
510 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Mp3_QueueInputBuffer_01, TestSize.Level1)
511 {
512     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
513     AVCodecBufferInfo info;
514     AVCodecBufferFlag flag = AVCODEC_BUFFER_FLAG_NONE;
515 
516     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceMp3Func());
517     sleep(1);
518     // case0 传参异常
519     index_ = -1;
520     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_NO_MEMORY, adec_->QueueInputBuffer(index_, info, flag));
521     // case1 info未赋值
522     index_ = 1024;
523     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_NO_MEMORY, adec_->QueueInputBuffer(index_, info, flag));
524 
525     // case2 EOS帧数据
526     index_ = 0;
527     info.presentationTimeUs = 0;
528     info.size = 0;
529     info.offset = 0;
530     flag = AVCODEC_BUFFER_FLAG_EOS;
531     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->QueueInputBuffer(index_, info, flag));
532     sleep(1);
533     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
534 }
535 
536 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Mp3_ReleaseOutputBuffer_01, TestSize.Level1)
537 {
538     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateMp3CodecFunc());
539     EXPECT_EQ(AVCS_ERR_OK, ProceMp3Func());
540 
541     // case1 传参异常
542     index_ = -1;
543     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->ReleaseOutputBuffer(index_));
544     index_ = 1024;
545     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->ReleaseOutputBuffer(index_));
546     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
547 }
548 
549 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Flac_Configure_01, TestSize.Level1)
550 {
551     // lack of correct key
552     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
553     format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_WIDTH);
554     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_CONFIGURE_MISMATCH_CHANNEL_COUNT, adec_->Configure(format_));
555 }
556 
557 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Flac_Configure_02, TestSize.Level1)
558 {
559     // correct key input
560     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
561     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
562     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
563     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
564     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
565 }
566 
567 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Flac_Configure_03, TestSize.Level1)
568 {
569     // correct key input with redundancy key input
570     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
571     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
572     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
573     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
574     format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_WIDTH);
575     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
576 }
577 
578 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Flac_Configure_04, TestSize.Level1)
579 {
580     // correct key input with wrong value type input
581     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
582     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
583     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
584     format_.PutIntValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
585     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
586 }
587 
588 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Flac_Configure_05, TestSize.Level1)
589 {
590     // correct key input with wrong value type input
591     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
592     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, INVALID_CHANNEL_COUNT);
593     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, INVALID_SAMPLE_RATE);
594     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
595     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
596 }
597 
598 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Flac_Configure_06, TestSize.Level1)
599 {
600     // empty format input
601     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
602     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
603 }
604 
605 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Flac_Start_01, TestSize.Level1)
606 {
607     // correct flow 1
608     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
609     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceFlacFunc());
610 }
611 
612 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Flac_Start_02, TestSize.Level1)
613 {
614     // correct flow 2
615     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
616     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceFlacFunc());
617     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
618     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Start());
619 }
620 
621 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Flac_Start_03, TestSize.Level1)
622 {
623     // wrong flow 1
624     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
625     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Start());
626 }
627 
628 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Flac_Start_04, TestSize.Level1)
629 {
630     // wrong flow 2
631     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
632     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceFlacFunc());
633     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
634     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Start());
635 }
636 
637 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Flac_Stop_01, TestSize.Level1)
638 {
639     // correct flow 1
640     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
641     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceFlacFunc());
642     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
643 }
644 
645 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Flac_Stop_02, TestSize.Level1)
646 {
647     // correct flow 2
648     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
649     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
650     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
651     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
652     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
653     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
654 }
655 
656 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Flac_Flush_01, TestSize.Level1)
657 {
658     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
659     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceFlacFunc());
660     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Flush());
661 }
662 
663 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Flac_Flush_02, TestSize.Level1)
664 {
665     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
666     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceFlacFunc());
667     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
668     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Flush());
669     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Release());
670 }
671 
672 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Flac_Reset_01, TestSize.Level1)
673 {
674     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
675     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceFlacFunc());
676     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
677     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Reset());
678 }
679 
680 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Flac_Reset_02, TestSize.Level1)
681 {
682     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
683     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
684     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
685     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
686     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
687     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Reset());
688 }
689 
690 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Flac_Reset_03, TestSize.Level1)
691 {
692     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
693     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceFlacFunc());
694     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Reset());
695 }
696 
697 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Flac_Release_01, TestSize.Level1)
698 {
699     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
700     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceFlacFunc());
701     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
702     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Release());
703 }
704 
705 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Flac_Release_02, TestSize.Level1)
706 {
707     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
708     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
709     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
710     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
711     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
712     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Release());
713 }
714 
715 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Flac_Release_03, TestSize.Level1)
716 {
717     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
718     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceFlacFunc());
719     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Release());
720 }
721 
722 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Flac_NotifyEos_01, TestSize.Level1)
723 {
724     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
725     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceFlacFunc());
726     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
727     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->NotifyEos());
728 }
729 
730 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Flac_SetParameter_01, TestSize.Level1)
731 {
732     // 尚未实现
733     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
734     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
735     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
736     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
737     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_INVALID_STATE, adec_->SetParameter(format_));
738 }
739 
740 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Flac_GetOutputFormat_01, TestSize.Level1)
741 {
742     // 尚未实现
743     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
744     EXPECT_EQ(AVCS_ERR_OK, ProceFlacFunc());
745     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->GetOutputFormat(format_));
746 }
747 
748 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Flac_QueueInputBuffer_01, TestSize.Level1)
749 {
750     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
751     AVCodecBufferInfo info;
752     AVCodecBufferFlag flag = AVCODEC_BUFFER_FLAG_NONE;
753 
754     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceFlacFunc());
755     sleep(1);
756     // case0 传参异常
757     index_ = -1;
758     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_NO_MEMORY, adec_->QueueInputBuffer(index_, info, flag));
759     // case1 info未赋值
760     index_ = 1024;
761     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_NO_MEMORY, adec_->QueueInputBuffer(index_, info, flag));
762 
763     // case2 EOS帧数据
764     index_ = 0;
765     info.presentationTimeUs = 0;
766     info.size = 0;
767     info.offset = 0;
768     flag = AVCODEC_BUFFER_FLAG_EOS;
769     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->QueueInputBuffer(index_, info, flag));
770     sleep(1);
771 }
772 
773 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Flac_ReleaseOutputBuffer_01, TestSize.Level1)
774 {
775     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateFlacCodecFunc());
776     EXPECT_EQ(AVCS_ERR_OK, ProceFlacFunc());
777 
778     // case1 传参异常
779     index_ = -1;
780     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->ReleaseOutputBuffer(index_));
781     index_ = 1024;
782     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->ReleaseOutputBuffer(index_));
783 }
784 
785 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Aac_Configure_01, TestSize.Level1)
786 {
787     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
788     // lack of correct key
789     format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_WIDTH);
790     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_CONFIGURE_MISMATCH_CHANNEL_COUNT, adec_->Configure(format_));
791 }
792 
793 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Aac_Configure_02, TestSize.Level1)
794 {
795     // correct key input
796     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
797     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
798     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
799     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
800     format_.PutIntValue(MediaDescriptionKey::MD_KEY_AAC_IS_ADTS, DEFAULT_AAC_TYPE);
801     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
802 }
803 
804 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Aac_Configure_03, TestSize.Level1)
805 {
806     // correct key input with redundancy key input
807     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
808     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
809     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
810     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
811     format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_WIDTH);
812     format_.PutIntValue(MediaDescriptionKey::MD_KEY_AAC_IS_ADTS, DEFAULT_AAC_TYPE);
813     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
814 }
815 
816 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Aac_Configure_04, TestSize.Level1)
817 {
818     // correct key input with wrong value type input
819     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
820     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
821     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
822     format_.PutIntValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
823     format_.PutIntValue(MediaDescriptionKey::MD_KEY_AAC_IS_ADTS, DEFAULT_AAC_TYPE);
824     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
825 }
826 
827 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Aac_Configure_05, TestSize.Level1)
828 {
829     // correct key input with wrong value type input
830     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
831     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, INVALID_CHANNEL_COUNT);
832     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, INVALID_SAMPLE_RATE);
833     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
834     format_.PutIntValue(MediaDescriptionKey::MD_KEY_AAC_IS_ADTS, DEFAULT_AAC_TYPE);
835     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
836 }
837 
838 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Aac_Configure_06, TestSize.Level1)
839 {
840     // correct key input
841     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
842     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
843     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
844     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
845     format_.PutIntValue(MediaDescriptionKey::MD_KEY_AAC_IS_ADTS, DEFAULT_AAC_LATM_TYPE);
846     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
847 }
848 
849 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Aac_Configure_07, TestSize.Level1)
850 {
851     // correct key input with redundancy key input
852     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
853     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
854     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
855     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
856     format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_WIDTH);
857     format_.PutIntValue(MediaDescriptionKey::MD_KEY_AAC_IS_ADTS, DEFAULT_AAC_LATM_TYPE);
858     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
859 }
860 
861 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Aac_Configure_08, TestSize.Level1)
862 {
863     // correct key input with wrong value type input
864     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
865     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
866     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
867     format_.PutIntValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
868     format_.PutIntValue(MediaDescriptionKey::MD_KEY_AAC_IS_ADTS, DEFAULT_AAC_LATM_TYPE);
869     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
870 }
871 
872 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Aac_Configure_09, TestSize.Level1)
873 {
874     // correct key input with wrong value type input
875     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
876     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, INVALID_CHANNEL_COUNT);
877     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, INVALID_SAMPLE_RATE);
878     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
879     format_.PutIntValue(MediaDescriptionKey::MD_KEY_AAC_IS_ADTS, DEFAULT_AAC_LATM_TYPE);
880     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
881 }
882 
883 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Aac_Configure_10, TestSize.Level1)
884 {
885     // empty format input
886     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
887     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
888 }
889 
890 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Aac_Start_01, TestSize.Level1)
891 {
892     // correct flow 1
893     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
894     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceAacFunc());
895 }
896 
897 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Aac_Start_02, TestSize.Level1)
898 {
899     // correct flow 2
900     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
901     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceAacFunc());
902     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
903     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Start());
904 }
905 
906 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Aac_Start_03, TestSize.Level1)
907 {
908     // wrong flow 1
909     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
910     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Start());
911 }
912 
913 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Aac_Start_04, TestSize.Level1)
914 {
915     // wrong flow 2
916     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
917     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceAacFunc());
918     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
919     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Start());
920 }
921 
922 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Aac_Stop_01, TestSize.Level1)
923 {
924     // correct flow 1
925     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
926     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceAacFunc());
927     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
928 }
929 
930 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Aac_Stop_02, TestSize.Level1)
931 {
932     // correct flow 2
933     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
934     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
935     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
936     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
937     format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_WIDTH);
938     format_.PutIntValue(MediaDescriptionKey::MD_KEY_AAC_IS_ADTS, DEFAULT_AAC_TYPE);
939     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
940     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
941 }
942 
943 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Aac_Flush_01, TestSize.Level1)
944 {
945     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
946     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceAacFunc());
947     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Flush());
948 }
949 
950 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Aac_Flush_02, TestSize.Level1)
951 {
952     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
953     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceAacFunc());
954     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
955     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Flush());
956     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Release());
957 }
958 
959 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Aac_Reset_01, TestSize.Level1)
960 {
961     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
962     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceAacFunc());
963     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
964     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Reset());
965 }
966 
967 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Aac_Reset_02, TestSize.Level1)
968 {
969     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
970     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
971     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
972     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
973     format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_WIDTH);
974     format_.PutIntValue(MediaDescriptionKey::MD_KEY_AAC_IS_ADTS, DEFAULT_AAC_TYPE);
975     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
976     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Reset());
977 }
978 
979 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Aac_Reset_03, TestSize.Level1)
980 {
981     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
982     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceAacFunc());
983     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Reset());
984 }
985 
986 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Aac_Release_01, TestSize.Level1)
987 {
988     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
989     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceAacFunc());
990     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
991     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Release());
992 }
993 
994 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Aac_Release_02, TestSize.Level1)
995 {
996     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
997     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
998     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
999     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
1000     format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_WIDTH);
1001     format_.PutIntValue(MediaDescriptionKey::MD_KEY_AAC_IS_ADTS, DEFAULT_AAC_TYPE);
1002     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
1003     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Release());
1004 }
1005 
1006 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Aac_Release_03, TestSize.Level1)
1007 {
1008     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
1009     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceAacFunc());
1010     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Release());
1011 }
1012 
1013 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Aac_NotifyEos_01, TestSize.Level1)
1014 {
1015     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
1016     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceAacFunc());
1017     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
1018     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->NotifyEos());
1019 }
1020 
1021 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Aac_SetParameter_01, TestSize.Level1)
1022 {
1023     // 尚未实现
1024     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
1025     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
1026     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
1027     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
1028     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_INVALID_STATE, adec_->SetParameter(format_));
1029 }
1030 
1031 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Aac_GetOutputFormat_01, TestSize.Level1)
1032 {
1033     // 尚未实现
1034     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
1035     EXPECT_EQ(AVCS_ERR_OK, ProceAacFunc());
1036     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->GetOutputFormat(format_));
1037 }
1038 
1039 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Aac_QueueInputBuffer_01, TestSize.Level1)
1040 {
1041     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
1042     AVCodecBufferInfo info;
1043     AVCodecBufferFlag flag = AVCODEC_BUFFER_FLAG_NONE;
1044 
1045     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceAacFunc());
1046     sleep(1);
1047     // case0 传参异常
1048     index_ = -1;
1049     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_NO_MEMORY, adec_->QueueInputBuffer(index_, info, flag));
1050     // case1 info未赋值
1051     index_ = 1024;
1052     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_NO_MEMORY, adec_->QueueInputBuffer(index_, info, flag));
1053 
1054     // case2 EOS帧数据
1055     index_ = 0;
1056     info.presentationTimeUs = 0;
1057     info.size = 0;
1058     info.offset = 0;
1059     flag = AVCODEC_BUFFER_FLAG_EOS;
1060     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->QueueInputBuffer(index_, info, flag));
1061     sleep(1);
1062 }
1063 
1064 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Aac_ReleaseOutputBuffer_01, TestSize.Level1)
1065 {
1066     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateAacCodecFunc());
1067     EXPECT_EQ(AVCS_ERR_OK, ProceAacFunc());
1068     // case1 传参异常
1069     index_ = -1;
1070     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->ReleaseOutputBuffer(index_));
1071     index_ = 1024;
1072     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->ReleaseOutputBuffer(index_));
1073 }
1074 
1075 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Opus_Configure_01, TestSize.Level1)
1076 {
1077     if (!CheckSoFunc()) {
1078         return;
1079     }
1080     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateOpusCodecFunc());
1081     // lack of correct key
1082     format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_WIDTH);
1083     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
1084 }
1085 
1086 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Opus_Configure_02, TestSize.Level1)
1087 {
1088     if (!CheckSoFunc()) {
1089         return;
1090     }
1091     // correct key input
1092     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateOpusCodecFunc());
1093     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
1094     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
1095     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
1096     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
1097 }
1098 
1099 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Opus_Configure_03, TestSize.Level1)
1100 {
1101     if (!CheckSoFunc()) {
1102         return;
1103     }
1104     // correct key input with redundancy key input
1105     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateOpusCodecFunc());
1106     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
1107     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
1108     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
1109     format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_WIDTH);
1110     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
1111 }
1112 
1113 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Opus_Configure_04, TestSize.Level1)
1114 {
1115     if (!CheckSoFunc()) {
1116         return;
1117     }
1118     // correct key input with wrong value type input
1119     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateOpusCodecFunc());
1120     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
1121     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
1122     format_.PutIntValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
1123     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
1124 }
1125 
1126 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Opus_Configure_05, TestSize.Level1)
1127 {
1128     if (!CheckSoFunc()) {
1129         return;
1130     }
1131     // correct key input with wrong value type input
1132     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateOpusCodecFunc());
1133     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, INVALID_CHANNEL_COUNT);
1134     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, INVALID_SAMPLE_RATE);
1135     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
1136     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
1137 }
1138 
1139 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Opus_Configure_06, TestSize.Level1)
1140 {
1141     if (!CheckSoFunc()) {
1142         return;
1143     }
1144     // correct key input
1145     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateOpusCodecFunc());
1146     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
1147     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
1148     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
1149     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
1150 }
1151 
1152 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Opus_Configure_07, TestSize.Level1)
1153 {
1154     if (!CheckSoFunc()) {
1155         return;
1156     }
1157     // correct key input with redundancy key input
1158     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateOpusCodecFunc());
1159     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
1160     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
1161     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
1162     format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_WIDTH);
1163     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
1164 }
1165 
1166 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Opus_Configure_08, TestSize.Level1)
1167 {
1168     if (!CheckSoFunc()) {
1169         return;
1170     }
1171     // correct key input with wrong value type input
1172     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateOpusCodecFunc());
1173     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
1174     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
1175     format_.PutIntValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
1176     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
1177 }
1178 
1179 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Opus_Configure_09, TestSize.Level1)
1180 {
1181     if (!CheckSoFunc()) {
1182         return;
1183     }
1184     // correct key input with wrong value type input
1185     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateOpusCodecFunc());
1186     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, INVALID_CHANNEL_COUNT);
1187     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, INVALID_SAMPLE_RATE);
1188     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
1189     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
1190 }
1191 
1192 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Opus_Configure_10, TestSize.Level1)
1193 {
1194     if (!CheckSoFunc()) {
1195         return;
1196     }
1197     // empty format input
1198     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateOpusCodecFunc());
1199     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
1200 }
1201 
1202 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Opus_Start_01, TestSize.Level1)
1203 {
1204     if (!CheckSoFunc()) {
1205         return;
1206     }
1207     // correct flow 1
1208     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateOpusCodecFunc());
1209     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceOpusFunc());
1210 }
1211 
1212 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Opus_Start_02, TestSize.Level1)
1213 {
1214     if (!CheckSoFunc()) {
1215         return;
1216     }
1217     // correct flow 2
1218     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateOpusCodecFunc());
1219     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceOpusFunc());
1220     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
1221     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Start());
1222 }
1223 
1224 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Opus_Start_03, TestSize.Level1)
1225 {
1226     if (!CheckSoFunc()) {
1227         return;
1228     }
1229     // wrong flow 1
1230     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateOpusCodecFunc());
1231     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Start());
1232 }
1233 
1234 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Opus_Start_04, TestSize.Level1)
1235 {
1236     if (!CheckSoFunc()) {
1237         return;
1238     }
1239     // wrong flow 2
1240     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateOpusCodecFunc());
1241     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceOpusFunc());
1242     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
1243     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Start());
1244 }
1245 
1246 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Opus_Stop_01, TestSize.Level1)
1247 {
1248     if (!CheckSoFunc()) {
1249         return;
1250     }
1251     // correct flow 1
1252     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateOpusCodecFunc());
1253     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceOpusFunc());
1254     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
1255 }
1256 
1257 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Opus_Stop_02, TestSize.Level1)
1258 {
1259     if (!CheckSoFunc()) {
1260         return;
1261     }
1262     // correct flow 2
1263     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateOpusCodecFunc());
1264     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
1265     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
1266     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
1267     format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_WIDTH);
1268     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
1269     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
1270 }
1271 
1272 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Opus_Flush_01, TestSize.Level1)
1273 {
1274     if (!CheckSoFunc()) {
1275         return;
1276     }
1277     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateOpusCodecFunc());
1278     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceOpusFunc());
1279     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Flush());
1280 }
1281 
1282 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Opus_Flush_02, TestSize.Level1)
1283 {
1284     if (!CheckSoFunc()) {
1285         return;
1286     }
1287     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateOpusCodecFunc());
1288     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceOpusFunc());
1289     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
1290     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Release());
1291 }
1292 
1293 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Opus_Reset_01, TestSize.Level1)
1294 {
1295     if (!CheckSoFunc()) {
1296         return;
1297     }
1298     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateOpusCodecFunc());
1299     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceOpusFunc());
1300     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
1301     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Reset());
1302 }
1303 
1304 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Opus_Reset_02, TestSize.Level1)
1305 {
1306     if (!CheckSoFunc()) {
1307         return;
1308     }
1309     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateOpusCodecFunc());
1310     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
1311     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
1312     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
1313     format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_WIDTH);
1314     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
1315     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Reset());
1316 }
1317 
1318 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Opus_Reset_03, TestSize.Level1)
1319 {
1320     if (!CheckSoFunc()) {
1321         return;
1322     }
1323     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateOpusCodecFunc());
1324     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceOpusFunc());
1325     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Reset());
1326 }
1327 
1328 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Opus_Release_01, TestSize.Level1)
1329 {
1330     if (!CheckSoFunc()) {
1331         return;
1332     }
1333     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateOpusCodecFunc());
1334     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceOpusFunc());
1335     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Stop());
1336     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Release());
1337 }
1338 
1339 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Opus_Release_02, TestSize.Level1)
1340 {
1341     if (!CheckSoFunc()) {
1342         return;
1343     }
1344     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateOpusCodecFunc());
1345     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
1346     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
1347     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
1348     format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_WIDTH);
1349     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Configure(format_));
1350     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Release());
1351 }
1352 
1353 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Opus_Release_03, TestSize.Level1)
1354 {
1355     if (!CheckSoFunc()) {
1356         return;
1357     }
1358     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateOpusCodecFunc());
1359     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceOpusFunc());
1360     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->Release());
1361 }
1362 
1363 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Opus_SetParameter_01, TestSize.Level1)
1364 {
1365     if (!CheckSoFunc()) {
1366         return;
1367     }
1368     // 尚未实现
1369     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateOpusCodecFunc());
1370     format_.PutIntValue(MediaDescriptionKey::MD_KEY_CHANNEL_COUNT, MAX_CHANNEL_COUNT);
1371     format_.PutIntValue(MediaDescriptionKey::MD_KEY_SAMPLE_RATE, DEFAULT_SAMPLE_RATE);
1372     format_.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, DEFAULT_BITRATE);
1373     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_INVALID_STATE, adec_->SetParameter(format_));
1374 }
1375 
1376 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Opus_GetOutputFormat_01, TestSize.Level1)
1377 {
1378     if (!CheckSoFunc()) {
1379         return;
1380     }
1381     // 尚未实现
1382     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateOpusCodecFunc());
1383     EXPECT_EQ(AVCS_ERR_OK, ProceOpusFunc());
1384     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->GetOutputFormat(format_));
1385 }
1386 
1387 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Opus_QueueInputBuffer_01, TestSize.Level1)
1388 {
1389     if (!CheckSoFunc()) {
1390         return;
1391     }
1392     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateOpusCodecFunc());
1393     AVCodecBufferInfo info;
1394     AVCodecBufferFlag flag = AVCODEC_BUFFER_FLAG_NONE;
1395 
1396     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, ProceOpusFunc());
1397     sleep(1);
1398     // case0 传参异常
1399     index_ = -1;
1400     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_NO_MEMORY, adec_->QueueInputBuffer(index_, info, flag));
1401     // case1 info未赋值
1402     index_ = 1024;
1403     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_NO_MEMORY, adec_->QueueInputBuffer(index_, info, flag));
1404 
1405     // case2 EOS帧数据
1406     index_ = 0;
1407     info.presentationTimeUs = 0;
1408     info.size = 0;
1409     info.offset = 0;
1410     flag = AVCODEC_BUFFER_FLAG_EOS;
1411     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->QueueInputBuffer(index_, info, flag));
1412     sleep(1);
1413 }
1414 
1415 HWTEST_F(AudioCodeDecoderUnitTest, audioDecoder_Opus_ReleaseOutputBuffer_01, TestSize.Level1)
1416 {
1417     if (!CheckSoFunc()) {
1418         return;
1419     }
1420     EXPECT_EQ(AVCodecServiceErrCode::AVCS_ERR_OK, CreateOpusCodecFunc());
1421     EXPECT_EQ(AVCS_ERR_OK, ProceOpusFunc());
1422     // case1 传参异常
1423     index_ = -1;
1424     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->ReleaseOutputBuffer(index_));
1425     index_ = 1024;
1426     EXPECT_NE(AVCodecServiceErrCode::AVCS_ERR_OK, adec_->ReleaseOutputBuffer(index_));
1427 }
1428 } // namespace MediaAVCodec
1429 } // namespace OHOS