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 #include <atomic>
16 #include <iostream>
17 #include <fstream>
18 #include <queue>
19 #include <string>
20 #include <thread>
21 #include "gtest/gtest.h"
22 #include "avcodec_audio_avbuffer_decoder_demo.h"
23 
24 using namespace std;
25 using namespace testing::ext;
26 using namespace OHOS;
27 using namespace OHOS::MediaAVCodec;
28 using namespace OHOS::MediaAVCodec::AudioBufferDemo;
29 
30 namespace {
31 class StatusCheckTest : public testing::Test {
32 public:
33     static void SetUpTestCase();
34     static void TearDownTestCase();
35     void SetUp() override;
36     void TearDown() override;
37 };
38 
SetUpTestCase()39 void StatusCheckTest::SetUpTestCase() {}
TearDownTestCase()40 void StatusCheckTest::TearDownTestCase() {}
SetUp()41 void StatusCheckTest::SetUp() {}
TearDown()42 void StatusCheckTest::TearDown() {}
43 
44 } // namespace
45 
46 /**
47  * @tc.number    : STATUS_CHECK_001
48  * @tc.name      : Create -> Configure
49  * @tc.desc      : status check test
50  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_001, TestSize.Level2)51 HWTEST_F(StatusCheckTest, STATUS_CHECK_001, TestSize.Level2)
52 {
53     OH_AVCodec *codec = nullptr;
54     OH_AVErrCode result0;
55     OH_AVFormat *format = OH_AVFormat_Create();
56     int32_t channel = 1;
57     int32_t sampleRate = 8000;  // 8000hz
58     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
59     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
60     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
61     ASSERT_EQ(result0, AV_ERR_OK);
62     result0 = aDecBufferDemo->Destroy(codec);
63     delete aDecBufferDemo;
64 }
65 
66 /**
67  * @tc.number    : STATUS_CHECK_002
68  * @tc.name      : Create -> Start
69  * @tc.desc      : status check test
70  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_002, TestSize.Level2)71 HWTEST_F(StatusCheckTest, STATUS_CHECK_002, TestSize.Level2)
72 {
73     OH_AVCodec *codec = nullptr;
74     OH_AVErrCode result0;
75     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
76     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
77     result0 = aDecBufferDemo->Start(codec);
78     ASSERT_EQ(result0, AV_ERR_INVALID_STATE);
79     result0 = aDecBufferDemo->Destroy(codec);
80     delete aDecBufferDemo;
81 }
82 
83 /**
84  * @tc.number    : STATUS_CHECK_003
85  * @tc.name      : Create -> Running
86  * @tc.desc      : status check test
87  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_003, TestSize.Level2)88 HWTEST_F(StatusCheckTest, STATUS_CHECK_003, TestSize.Level2)
89 {
90     OH_AVCodec *codec = nullptr;
91     OH_AVErrCode result0;
92     uint32_t index;
93     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
94     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
95     index = aDecBufferDemo->GetInputIndex();
96     result0 = aDecBufferDemo->PushInputData(codec, index);
97     ASSERT_EQ(result0, AV_ERR_INVALID_STATE);
98     result0 = aDecBufferDemo->Destroy(codec);
99     delete aDecBufferDemo;
100 }
101 
102 /**
103  * @tc.number    : STATUS_CHECK_004
104  * @tc.name      : Create -> EOS
105  * @tc.desc      : status check test
106  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_004, TestSize.Level2)107 HWTEST_F(StatusCheckTest, STATUS_CHECK_004, TestSize.Level2)
108 {
109     OH_AVCodec *codec = nullptr;
110     OH_AVErrCode result0;
111     uint32_t index;
112     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
113     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
114     index = aDecBufferDemo->GetInputIndex();
115     result0 = aDecBufferDemo->PushInputDataEOS(codec, index);
116     ASSERT_EQ(result0, AV_ERR_INVALID_STATE);
117     result0 = aDecBufferDemo->Destroy(codec);
118     delete aDecBufferDemo;
119 }
120 
121 /**
122  * @tc.number    : STATUS_CHECK_005
123  * @tc.name      : Create -> Flush
124  * @tc.desc      : status check test
125  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_005, TestSize.Level2)126 HWTEST_F(StatusCheckTest, STATUS_CHECK_005, TestSize.Level2)
127 {
128     OH_AVCodec *codec = nullptr;
129     OH_AVErrCode result0;
130     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
131     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
132     result0 = aDecBufferDemo->Flush(codec);
133     ASSERT_EQ(result0, AV_ERR_INVALID_STATE);
134     result0 = aDecBufferDemo->Destroy(codec);
135     delete aDecBufferDemo;
136 }
137 
138 /**
139  * @tc.number    : STATUS_CHECK_006
140  * @tc.name      : Create -> Stop
141  * @tc.desc      : status check test
142  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_006, TestSize.Level2)143 HWTEST_F(StatusCheckTest, STATUS_CHECK_006, TestSize.Level2)
144 {
145     OH_AVCodec *codec = nullptr;
146     OH_AVErrCode result0;
147     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
148     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
149     result0 = aDecBufferDemo->Stop(codec);
150     ASSERT_EQ(result0, AV_ERR_INVALID_STATE);
151     result0 = aDecBufferDemo->Destroy(codec);
152     delete aDecBufferDemo;
153 }
154 
155 /**
156  * @tc.number    : STATUS_CHECK_007
157  * @tc.name      : Create -> Reset
158  * @tc.desc      : status check test
159  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_007, TestSize.Level2)160 HWTEST_F(StatusCheckTest, STATUS_CHECK_007, TestSize.Level2)
161 {
162     OH_AVCodec *codec = nullptr;
163     OH_AVErrCode result0;
164     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
165     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
166     result0 = aDecBufferDemo->Reset(codec);
167     ASSERT_EQ(result0, AV_ERR_OK);
168     result0 = aDecBufferDemo->Destroy(codec);
169     delete aDecBufferDemo;
170 }
171 
172 /**
173  * @tc.number    : STATUS_CHECK_008
174  * @tc.name      : Create -> Release
175  * @tc.desc      : status check test
176  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_008, TestSize.Level2)177 HWTEST_F(StatusCheckTest, STATUS_CHECK_008, TestSize.Level2)
178 {
179     OH_AVCodec *codec = nullptr;
180     OH_AVErrCode result0;
181     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
182     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
183     result0 = aDecBufferDemo->Destroy(codec);
184     ASSERT_EQ(result0, AV_ERR_OK);
185     delete aDecBufferDemo;
186 }
187 
188 /**
189  * @tc.number    : STATUS_CHECK_009
190  * @tc.name      : Configure -> Configure
191  * @tc.desc      : status check test
192  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_009, TestSize.Level2)193 HWTEST_F(StatusCheckTest, STATUS_CHECK_009, TestSize.Level2)
194 {
195     OH_AVCodec *codec = nullptr;
196     OH_AVFormat *format = OH_AVFormat_Create();
197     int32_t channel = 1;
198     int32_t sampleRate = 8000;  // 8000hz
199     OH_AVErrCode result0;
200     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
201     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
202     ASSERT_NE(codec, nullptr);
203     result0 = aDecBufferDemo->SetCallback(codec);
204     ASSERT_EQ(result0, AV_ERR_OK);
205     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
206     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
207     ASSERT_EQ(result0, AV_ERR_INVALID_STATE);
208     result0 = aDecBufferDemo->Destroy(codec);
209     delete aDecBufferDemo;
210 }
211 
212 /**
213  * @tc.number    : STATUS_CHECK_010
214  * @tc.name      : Configure -> Start
215  * @tc.desc      : status check test
216  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_010, TestSize.Level2)217 HWTEST_F(StatusCheckTest, STATUS_CHECK_010, TestSize.Level2)
218 {
219     OH_AVCodec *codec = nullptr;
220     OH_AVFormat *format = OH_AVFormat_Create();
221     int32_t channel = 1;
222     int32_t sampleRate = 8000;  // 8000hz
223     OH_AVErrCode result0;
224     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
225     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
226     ASSERT_NE(codec, nullptr);
227     result0 = aDecBufferDemo->SetCallback(codec);
228     ASSERT_EQ(result0, AV_ERR_OK);
229     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
230     result0 = aDecBufferDemo->Start(codec);
231     ASSERT_EQ(result0, AV_ERR_OK);
232     result0 = aDecBufferDemo->Destroy(codec);
233     delete aDecBufferDemo;
234 }
235 
236 /**
237  * @tc.number    : STATUS_CHECK_011
238  * @tc.name      : Configure -> Running
239  * @tc.desc      : status check test
240  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_011, TestSize.Level2)241 HWTEST_F(StatusCheckTest, STATUS_CHECK_011, TestSize.Level2)
242 {
243     OH_AVCodec *codec = nullptr;
244     OH_AVFormat *format = OH_AVFormat_Create();
245     int32_t channel = 1;
246     int32_t sampleRate = 8000;  // 8000hz
247     OH_AVErrCode result0;
248     uint32_t index;
249     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
250     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
251     ASSERT_NE(codec, nullptr);
252     result0 = aDecBufferDemo->SetCallback(codec);
253     ASSERT_EQ(result0, AV_ERR_OK);
254     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
255     index = aDecBufferDemo->GetInputIndex();
256     result0 = aDecBufferDemo->PushInputData(codec, index);
257     ASSERT_EQ(result0, AV_ERR_INVALID_STATE);
258     result0 = aDecBufferDemo->Destroy(codec);
259     delete aDecBufferDemo;
260 }
261 
262 /**
263  * @tc.number    : STATUS_CHECK_012
264  * @tc.name      : Configure -> EOS
265  * @tc.desc      : status check test
266  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_012, TestSize.Level2)267 HWTEST_F(StatusCheckTest, STATUS_CHECK_012, TestSize.Level2)
268 {
269     OH_AVCodec *codec = nullptr;
270     OH_AVFormat *format = OH_AVFormat_Create();
271     int32_t channel = 1;
272     int32_t sampleRate = 8000;  // 8000hz
273     OH_AVErrCode result0;
274     uint32_t index;
275     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
276     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
277     ASSERT_NE(codec, nullptr);
278     result0 = aDecBufferDemo->SetCallback(codec);
279     ASSERT_EQ(result0, AV_ERR_OK);
280     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
281     index = aDecBufferDemo->GetInputIndex();
282     index = -1;
283     result0 = aDecBufferDemo->PushInputDataEOS(codec, index);
284     ASSERT_NE(result0, AV_ERR_OK);
285     result0 = aDecBufferDemo->Destroy(codec);
286     delete aDecBufferDemo;
287 }
288 
289 /**
290  * @tc.number    : STATUS_CHECK_013
291  * @tc.name      : Configure -> Flush
292  * @tc.desc      : status check test
293  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_013, TestSize.Level2)294 HWTEST_F(StatusCheckTest, STATUS_CHECK_013, TestSize.Level2)
295 {
296     OH_AVCodec *codec = nullptr;
297     OH_AVFormat *format = OH_AVFormat_Create();
298     int32_t channel = 1;
299     int32_t sampleRate = 8000;  // 8000hz
300     OH_AVErrCode result0;
301     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
302     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
303     ASSERT_NE(codec, nullptr);
304     result0 = aDecBufferDemo->SetCallback(codec);
305     ASSERT_EQ(result0, AV_ERR_OK);
306     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
307     result0 = aDecBufferDemo->Flush(codec);
308     ASSERT_EQ(result0, AV_ERR_INVALID_STATE);
309     result0 = aDecBufferDemo->Destroy(codec);
310     delete aDecBufferDemo;
311 }
312 
313 /**
314  * @tc.number    : STATUS_CHECK_014
315  * @tc.name      : Configure -> Stop
316  * @tc.desc      : status check test
317  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_014, TestSize.Level2)318 HWTEST_F(StatusCheckTest, STATUS_CHECK_014, TestSize.Level2)
319 {
320     OH_AVCodec *codec = nullptr;
321     OH_AVFormat *format = OH_AVFormat_Create();
322     int32_t channel = 1;
323     int32_t sampleRate = 8000;  // 8000hz
324     OH_AVErrCode result0;
325     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
326     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
327     ASSERT_NE(codec, nullptr);
328     result0 = aDecBufferDemo->SetCallback(codec);
329     ASSERT_EQ(result0, AV_ERR_OK);
330     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
331     result0 = aDecBufferDemo->Stop(codec);
332     ASSERT_EQ(result0, AV_ERR_INVALID_STATE);
333     result0 = aDecBufferDemo->Destroy(codec);
334     delete aDecBufferDemo;
335 }
336 
337 /**
338  * @tc.number    : STATUS_CHECK_015
339  * @tc.name      : Configure -> Reset
340  * @tc.desc      : status check test
341  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_015, TestSize.Level2)342 HWTEST_F(StatusCheckTest, STATUS_CHECK_015, TestSize.Level2)
343 {
344     OH_AVCodec *codec = nullptr;
345     OH_AVFormat *format = OH_AVFormat_Create();
346     int32_t channel = 1;
347     int32_t sampleRate = 8000;  // 8000hz
348     OH_AVErrCode result0;
349     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
350     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
351     ASSERT_NE(codec, nullptr);
352     result0 = aDecBufferDemo->SetCallback(codec);
353     ASSERT_EQ(result0, AV_ERR_OK);
354     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
355     result0 = aDecBufferDemo->Reset(codec);
356     ASSERT_EQ(result0, AV_ERR_OK);
357     result0 = aDecBufferDemo->Destroy(codec);
358     delete aDecBufferDemo;
359 }
360 
361 /**
362  * @tc.number    : STATUS_CHECK_016
363  * @tc.name      : Configure -> Release
364  * @tc.desc      : status check test
365  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_016, TestSize.Level2)366 HWTEST_F(StatusCheckTest, STATUS_CHECK_016, TestSize.Level2)
367 {
368     OH_AVCodec *codec = nullptr;
369     OH_AVFormat *format = OH_AVFormat_Create();
370     int32_t channel = 1;
371     int32_t sampleRate = 8000;  // 8000hz
372     OH_AVErrCode result0;
373     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
374     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
375     ASSERT_NE(codec, nullptr);
376     result0 = aDecBufferDemo->SetCallback(codec);
377     ASSERT_EQ(result0, AV_ERR_OK);
378     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
379     result0 = aDecBufferDemo->Destroy(codec);
380     ASSERT_EQ(result0, AV_ERR_OK);
381     delete aDecBufferDemo;
382 }
383 
384 /**
385  * @tc.number    : STATUS_CHECK_017
386  * @tc.name      : Start -> Configure
387  * @tc.desc      : status check test
388  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_017, TestSize.Level2)389 HWTEST_F(StatusCheckTest, STATUS_CHECK_017, TestSize.Level2)
390 {
391     OH_AVCodec *codec = nullptr;
392     OH_AVFormat *format = OH_AVFormat_Create();
393     int32_t channel = 1;
394     int32_t sampleRate = 8000;  // 8000hz
395     OH_AVErrCode result0;
396     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
397     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
398     ASSERT_NE(codec, nullptr);
399     result0 = aDecBufferDemo->SetCallback(codec);
400     ASSERT_EQ(result0, AV_ERR_OK);
401     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
402     ASSERT_EQ(result0, AV_ERR_OK);
403     result0 = aDecBufferDemo->Start(codec);
404     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
405     ASSERT_EQ(result0, AV_ERR_INVALID_STATE);
406     result0 = aDecBufferDemo->Destroy(codec);
407     delete aDecBufferDemo;
408 }
409 
410 /**
411  * @tc.number    : STATUS_CHECK_018
412  * @tc.name      : Start -> Start
413  * @tc.desc      : status check test
414  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_018, TestSize.Level2)415 HWTEST_F(StatusCheckTest, STATUS_CHECK_018, TestSize.Level2)
416 {
417     OH_AVCodec *codec = nullptr;
418     OH_AVFormat *format = OH_AVFormat_Create();
419     int32_t channel = 1;
420     int32_t sampleRate = 8000;  // 8000hz
421     OH_AVErrCode result0;
422     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
423     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
424     ASSERT_NE(codec, nullptr);
425     result0 = aDecBufferDemo->SetCallback(codec);
426     ASSERT_EQ(result0, AV_ERR_OK);
427     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
428     ASSERT_EQ(result0, AV_ERR_OK);
429     result0 = aDecBufferDemo->Start(codec);
430     result0 = aDecBufferDemo->Start(codec);
431     ASSERT_EQ(result0, AV_ERR_INVALID_STATE);
432     result0 = aDecBufferDemo->Destroy(codec);
433     delete aDecBufferDemo;
434 }
435 
436 /**
437  * @tc.number    : STATUS_CHECK_019
438  * @tc.name      : Start -> Running
439  * @tc.desc      : status check test
440  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_019, TestSize.Level2)441 HWTEST_F(StatusCheckTest, STATUS_CHECK_019, TestSize.Level2)
442 {
443     OH_AVCodec *codec = nullptr;
444     OH_AVFormat *format = OH_AVFormat_Create();
445     int32_t channel = 1;
446     int32_t sampleRate = 8000;  // 8000hz
447     OH_AVErrCode result0;
448     uint32_t index;
449     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
450     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
451     ASSERT_NE(codec, nullptr);
452     result0 = aDecBufferDemo->SetCallback(codec);
453     ASSERT_EQ(result0, AV_ERR_OK);
454     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
455     ASSERT_EQ(result0, AV_ERR_OK);
456     result0 = aDecBufferDemo->Start(codec);
457     index = aDecBufferDemo->GetInputIndex();
458     result0 = aDecBufferDemo->PushInputData(codec, index);
459     ASSERT_EQ(result0, AV_ERR_UNKNOWN);
460     result0 = aDecBufferDemo->Destroy(codec);
461     delete aDecBufferDemo;
462 }
463 
464 /**
465  * @tc.number    : STATUS_CHECK_020
466  * @tc.name      : Start -> EOS
467  * @tc.desc      : status check test
468  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_020, TestSize.Level2)469 HWTEST_F(StatusCheckTest, STATUS_CHECK_020, TestSize.Level2)
470 {
471     OH_AVCodec *codec = nullptr;
472     OH_AVFormat *format = OH_AVFormat_Create();
473     int32_t channel = 1;
474     int32_t sampleRate = 8000;  // 8000hz
475     OH_AVErrCode result0;
476     uint32_t index;
477     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
478     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
479     ASSERT_NE(codec, nullptr);
480     result0 = aDecBufferDemo->SetCallback(codec);
481     ASSERT_EQ(result0, AV_ERR_OK);
482     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
483     ASSERT_EQ(result0, AV_ERR_OK);
484     result0 = aDecBufferDemo->Start(codec);
485     index = aDecBufferDemo->GetInputIndex();
486     index = -1;
487     result0 = aDecBufferDemo->PushInputDataEOS(codec, index);
488     ASSERT_NE(result0, AV_ERR_OK);
489     result0 = aDecBufferDemo->Destroy(codec);
490     delete aDecBufferDemo;
491 }
492 
493 /**
494  * @tc.number    : STATUS_CHECK_021
495  * @tc.name      : Start -> Flush
496  * @tc.desc      : status check test
497  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_021, TestSize.Level2)498 HWTEST_F(StatusCheckTest, STATUS_CHECK_021, TestSize.Level2)
499 {
500     OH_AVCodec *codec = nullptr;
501     OH_AVFormat *format = OH_AVFormat_Create();
502     int32_t channel = 1;
503     int32_t sampleRate = 8000;  // 8000hz
504     OH_AVErrCode result0;
505     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
506     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
507     ASSERT_NE(codec, nullptr);
508     result0 = aDecBufferDemo->SetCallback(codec);
509     ASSERT_EQ(result0, AV_ERR_OK);
510     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
511     ASSERT_EQ(result0, AV_ERR_OK);
512     result0 = aDecBufferDemo->Start(codec);
513     result0 = aDecBufferDemo->Flush(codec);
514     ASSERT_EQ(result0, AV_ERR_OK);
515     result0 = aDecBufferDemo->Destroy(codec);
516     delete aDecBufferDemo;
517 }
518 
519 /**
520  * @tc.number    : STATUS_CHECK_022
521  * @tc.name      : Start -> Stop
522  * @tc.desc      : status check test
523  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_022, TestSize.Level2)524 HWTEST_F(StatusCheckTest, STATUS_CHECK_022, TestSize.Level2)
525 {
526     OH_AVCodec *codec = nullptr;
527     OH_AVFormat *format = OH_AVFormat_Create();
528     int32_t channel = 1;
529     int32_t sampleRate = 8000;  // 8000hz
530     OH_AVErrCode result0;
531     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
532     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
533     ASSERT_NE(codec, nullptr);
534     result0 = aDecBufferDemo->SetCallback(codec);
535     ASSERT_EQ(result0, AV_ERR_OK);
536     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
537     ASSERT_EQ(result0, AV_ERR_OK);
538     result0 = aDecBufferDemo->Start(codec);
539     result0 = aDecBufferDemo->Stop(codec);
540     ASSERT_EQ(result0, AV_ERR_OK);
541     result0 = aDecBufferDemo->Destroy(codec);
542     delete aDecBufferDemo;
543 }
544 
545 /**
546  * @tc.number    : STATUS_CHECK_023
547  * @tc.name      : Start -> Reset
548  * @tc.desc      : status check test
549  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_023, TestSize.Level2)550 HWTEST_F(StatusCheckTest, STATUS_CHECK_023, TestSize.Level2)
551 {
552     OH_AVCodec *codec = nullptr;
553     OH_AVFormat *format = OH_AVFormat_Create();
554     int32_t channel = 1;
555     int32_t sampleRate = 8000;  // 8000hz
556     OH_AVErrCode result0;
557     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
558     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
559     ASSERT_NE(codec, nullptr);
560     result0 = aDecBufferDemo->SetCallback(codec);
561     ASSERT_EQ(result0, AV_ERR_OK);
562     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
563     ASSERT_EQ(result0, AV_ERR_OK);
564     result0 = aDecBufferDemo->Start(codec);
565     result0 = aDecBufferDemo->Reset(codec);
566     ASSERT_EQ(result0, AV_ERR_OK);
567     result0 = aDecBufferDemo->Destroy(codec);
568     delete aDecBufferDemo;
569 }
570 
571 /**
572  * @tc.number    : STATUS_CHECK_024
573  * @tc.name      : Start -> Release
574  * @tc.desc      : status check test
575  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_024, TestSize.Level2)576 HWTEST_F(StatusCheckTest, STATUS_CHECK_024, TestSize.Level2)
577 {
578     OH_AVCodec *codec = nullptr;
579     OH_AVFormat *format = OH_AVFormat_Create();
580     int32_t channel = 1;
581     int32_t sampleRate = 8000;  // 8000hz
582     OH_AVErrCode result0;
583     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
584     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
585     ASSERT_NE(codec, nullptr);
586     result0 = aDecBufferDemo->SetCallback(codec);
587     ASSERT_EQ(result0, AV_ERR_OK);
588     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
589     ASSERT_EQ(result0, AV_ERR_OK);
590     result0 = aDecBufferDemo->Start(codec);
591     result0 = aDecBufferDemo->Destroy(codec);
592     ASSERT_EQ(result0, AV_ERR_OK);
593     delete aDecBufferDemo;
594 }
595 
596 /**
597  * @tc.number    : STATUS_CHECK_025
598  * @tc.name      : Running -> Configure
599  * @tc.desc      : status check test
600  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_025, TestSize.Level2)601 HWTEST_F(StatusCheckTest, STATUS_CHECK_025, TestSize.Level2)
602 {
603     OH_AVCodec *codec = nullptr;
604     OH_AVFormat *format = OH_AVFormat_Create();
605     int32_t channel = 1;
606     int32_t sampleRate = 8000;  // 8000hz
607     uint32_t index;
608     OH_AVErrCode result0;
609     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
610     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
611     ASSERT_NE(codec, nullptr);
612     result0 = aDecBufferDemo->SetCallback(codec);
613     ASSERT_EQ(result0, AV_ERR_OK);
614     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
615     ASSERT_EQ(result0, AV_ERR_OK);
616     result0 = aDecBufferDemo->Start(codec);
617     ASSERT_EQ(result0, AV_ERR_OK);
618     index = aDecBufferDemo->GetInputIndex();
619     result0 = aDecBufferDemo->PushInputData(codec, index);
620     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
621     ASSERT_EQ(result0, AV_ERR_INVALID_STATE);
622     result0 = aDecBufferDemo->Destroy(codec);
623     delete aDecBufferDemo;
624 }
625 
626 /**
627  * @tc.number    : STATUS_CHECK_026
628  * @tc.name      : Running -> Start
629  * @tc.desc      : status check test
630  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_026, TestSize.Level2)631 HWTEST_F(StatusCheckTest, STATUS_CHECK_026, TestSize.Level2)
632 {
633     OH_AVCodec *codec = nullptr;
634     OH_AVFormat *format = OH_AVFormat_Create();
635     int32_t channel = 1;
636     int32_t sampleRate = 8000;  // 8000hz
637     uint32_t index;
638     OH_AVErrCode result0;
639     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
640     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
641     ASSERT_NE(codec, nullptr);
642     result0 = aDecBufferDemo->SetCallback(codec);
643     ASSERT_EQ(result0, AV_ERR_OK);
644     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
645     ASSERT_EQ(result0, AV_ERR_OK);
646     result0 = aDecBufferDemo->Start(codec);
647     ASSERT_EQ(result0, AV_ERR_OK);
648     index = aDecBufferDemo->GetInputIndex();
649     result0 = aDecBufferDemo->PushInputData(codec, index);
650     result0 = aDecBufferDemo->Start(codec);
651     ASSERT_EQ(result0, AV_ERR_INVALID_STATE);
652     result0 = aDecBufferDemo->Destroy(codec);
653     delete aDecBufferDemo;
654 }
655 
656 /**
657  * @tc.number    : STATUS_CHECK_027
658  * @tc.name      : Running -> Running
659  * @tc.desc      : status check test
660  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_027, TestSize.Level2)661 HWTEST_F(StatusCheckTest, STATUS_CHECK_027, TestSize.Level2)
662 {
663     OH_AVCodec *codec = nullptr;
664     OH_AVFormat *format = OH_AVFormat_Create();
665     int32_t channel = 1;
666     int32_t sampleRate = 8000;  // 8000hz
667     uint32_t index;
668     OH_AVErrCode result0;
669     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
670     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
671     ASSERT_NE(codec, nullptr);
672     result0 = aDecBufferDemo->SetCallback(codec);
673     ASSERT_EQ(result0, AV_ERR_OK);
674     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
675     ASSERT_EQ(result0, AV_ERR_OK);
676     result0 = aDecBufferDemo->Start(codec);
677     ASSERT_EQ(result0, AV_ERR_OK);
678     index = aDecBufferDemo->GetInputIndex();
679     result0 = aDecBufferDemo->PushInputData(codec, index);
680     index = aDecBufferDemo->GetInputIndex();
681     result0 = aDecBufferDemo->PushInputData(codec, index);
682     ASSERT_EQ(result0, AV_ERR_UNKNOWN);
683     result0 = aDecBufferDemo->Destroy(codec);
684     delete aDecBufferDemo;
685 }
686 
687 /**
688  * @tc.number    : STATUS_CHECK_028
689  * @tc.name      : Running -> EOS
690  * @tc.desc      : status check test
691  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_028, TestSize.Level2)692 HWTEST_F(StatusCheckTest, STATUS_CHECK_028, TestSize.Level2)
693 {
694     OH_AVCodec *codec = nullptr;
695     OH_AVFormat *format = OH_AVFormat_Create();
696     int32_t channel = 1;
697     int32_t sampleRate = 8000;  // 8000hz
698     uint32_t index;
699     OH_AVErrCode result0;
700     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
701     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
702     ASSERT_NE(codec, nullptr);
703     result0 = aDecBufferDemo->SetCallback(codec);
704     ASSERT_EQ(result0, AV_ERR_OK);
705     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
706     ASSERT_EQ(result0, AV_ERR_OK);
707     result0 = aDecBufferDemo->Start(codec);
708     ASSERT_EQ(result0, AV_ERR_OK);
709     index = aDecBufferDemo->GetInputIndex();
710     result0 = aDecBufferDemo->PushInputData(codec, index);
711     index = aDecBufferDemo->GetInputIndex();
712     index = -1;
713     result0 = aDecBufferDemo->PushInputDataEOS(codec, index);
714     ASSERT_NE(result0, AV_ERR_OK);
715     result0 = aDecBufferDemo->Destroy(codec);
716     delete aDecBufferDemo;
717 }
718 
719 /**
720  * @tc.number    : STATUS_CHECK_029
721  * @tc.name      : Running -> Flush
722  * @tc.desc      : status check test
723  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_029, TestSize.Level2)724 HWTEST_F(StatusCheckTest, STATUS_CHECK_029, TestSize.Level2)
725 {
726     OH_AVCodec *codec = nullptr;
727     OH_AVFormat *format = OH_AVFormat_Create();
728     int32_t channel = 1;
729     int32_t sampleRate = 8000;  // 8000hz
730     uint32_t index;
731     OH_AVErrCode result0;
732     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
733     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
734     ASSERT_NE(codec, nullptr);
735     result0 = aDecBufferDemo->SetCallback(codec);
736     ASSERT_EQ(result0, AV_ERR_OK);
737     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
738     ASSERT_EQ(result0, AV_ERR_OK);
739     result0 = aDecBufferDemo->Start(codec);
740     ASSERT_EQ(result0, AV_ERR_OK);
741     index = aDecBufferDemo->GetInputIndex();
742     result0 = aDecBufferDemo->PushInputData(codec, index);
743     result0 = aDecBufferDemo->Flush(codec);
744     ASSERT_EQ(result0, AV_ERR_OK);
745     result0 = aDecBufferDemo->Destroy(codec);
746     delete aDecBufferDemo;
747 }
748 
749 /**
750  * @tc.number    : STATUS_CHECK_030
751  * @tc.name      : Running -> Stop
752  * @tc.desc      : status check test
753  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_030, TestSize.Level2)754 HWTEST_F(StatusCheckTest, STATUS_CHECK_030, TestSize.Level2)
755 {
756     OH_AVCodec *codec = nullptr;
757     OH_AVFormat *format = OH_AVFormat_Create();
758     int32_t channel = 1;
759     int32_t sampleRate = 8000;  // 8000hz
760     uint32_t index;
761     OH_AVErrCode result0;
762     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
763     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
764     ASSERT_NE(codec, nullptr);
765     result0 = aDecBufferDemo->SetCallback(codec);
766     ASSERT_EQ(result0, AV_ERR_OK);
767     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
768     ASSERT_EQ(result0, AV_ERR_OK);
769     result0 = aDecBufferDemo->Start(codec);
770     ASSERT_EQ(result0, AV_ERR_OK);
771     index = aDecBufferDemo->GetInputIndex();
772     result0 = aDecBufferDemo->PushInputData(codec, index);
773     result0 = aDecBufferDemo->Stop(codec);
774     ASSERT_EQ(result0, AV_ERR_OK);
775     result0 = aDecBufferDemo->Destroy(codec);
776     delete aDecBufferDemo;
777 }
778 
779 /**
780  * @tc.number    : STATUS_CHECK_031
781  * @tc.name      : Running -> Reset
782  * @tc.desc      : status check test
783  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_031, TestSize.Level2)784 HWTEST_F(StatusCheckTest, STATUS_CHECK_031, TestSize.Level2)
785 {
786     OH_AVCodec *codec = nullptr;
787     OH_AVFormat *format = OH_AVFormat_Create();
788     int32_t channel = 1;
789     int32_t sampleRate = 8000;  // 8000hz
790     uint32_t index;
791     OH_AVErrCode result0;
792     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
793     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
794     ASSERT_NE(codec, nullptr);
795     result0 = aDecBufferDemo->SetCallback(codec);
796     ASSERT_EQ(result0, AV_ERR_OK);
797     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
798     ASSERT_EQ(result0, AV_ERR_OK);
799     result0 = aDecBufferDemo->Start(codec);
800     ASSERT_EQ(result0, AV_ERR_OK);
801     index = aDecBufferDemo->GetInputIndex();
802     result0 = aDecBufferDemo->PushInputData(codec, index);
803     result0 = aDecBufferDemo->Reset(codec);
804     ASSERT_EQ(result0, AV_ERR_OK);
805     result0 = aDecBufferDemo->Destroy(codec);
806     delete aDecBufferDemo;
807 }
808 
809 /**
810  * @tc.number    : STATUS_CHECK_032
811  * @tc.name      : Running -> Release
812  * @tc.desc      : status check test
813  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_032, TestSize.Level2)814 HWTEST_F(StatusCheckTest, STATUS_CHECK_032, TestSize.Level2)
815 {
816     OH_AVCodec *codec = nullptr;
817     OH_AVFormat *format = OH_AVFormat_Create();
818     int32_t channel = 1;
819     int32_t sampleRate = 8000;  // 8000hz
820     uint32_t index;
821     OH_AVErrCode result0;
822     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
823     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
824     ASSERT_NE(codec, nullptr);
825     result0 = aDecBufferDemo->SetCallback(codec);
826     ASSERT_EQ(result0, AV_ERR_OK);
827     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
828     ASSERT_EQ(result0, AV_ERR_OK);
829     result0 = aDecBufferDemo->Start(codec);
830     ASSERT_EQ(result0, AV_ERR_OK);
831     index = aDecBufferDemo->GetInputIndex();
832     result0 = aDecBufferDemo->PushInputData(codec, index);
833     result0 = aDecBufferDemo->Destroy(codec);
834     ASSERT_EQ(result0, AV_ERR_OK);
835     delete aDecBufferDemo;
836 }
837 
838 /**
839  * @tc.number    : STATUS_CHECK_033
840  * @tc.name      : EOS -> Configure
841  * @tc.desc      : status check test
842  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_033, TestSize.Level2)843 HWTEST_F(StatusCheckTest, STATUS_CHECK_033, TestSize.Level2)
844 {
845     OH_AVCodec *codec = nullptr;
846     OH_AVFormat *format = OH_AVFormat_Create();
847     int32_t channel = 1;
848     int32_t sampleRate = 8000;  // 8000hz
849     uint32_t index;
850     OH_AVErrCode result0;
851     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
852     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
853     ASSERT_NE(codec, nullptr);
854     result0 = aDecBufferDemo->SetCallback(codec);
855     ASSERT_EQ(result0, AV_ERR_OK);
856     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
857     ASSERT_EQ(result0, AV_ERR_OK);
858     result0 = aDecBufferDemo->Start(codec);
859     ASSERT_EQ(result0, AV_ERR_OK);
860     index = aDecBufferDemo->GetInputIndex();
861     result0 = aDecBufferDemo->PushInputDataEOS(codec, index);
862     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
863     ASSERT_EQ(result0, AV_ERR_INVALID_STATE);
864     result0 = aDecBufferDemo->Destroy(codec);
865     delete aDecBufferDemo;
866 }
867 
868 /**
869  * @tc.number    : STATUS_CHECK_034
870  * @tc.name      : EOS -> Start
871  * @tc.desc      : status check test
872  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_034, TestSize.Level2)873 HWTEST_F(StatusCheckTest, STATUS_CHECK_034, TestSize.Level2)
874 {
875     OH_AVCodec *codec = nullptr;
876     OH_AVFormat *format = OH_AVFormat_Create();
877     int32_t channel = 1;
878     int32_t sampleRate = 8000;  // 8000hz
879     uint32_t index;
880     OH_AVErrCode result0;
881     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
882     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
883     ASSERT_NE(codec, nullptr);
884     result0 = aDecBufferDemo->SetCallback(codec);
885     ASSERT_EQ(result0, AV_ERR_OK);
886     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
887     ASSERT_EQ(result0, AV_ERR_OK);
888     result0 = aDecBufferDemo->Start(codec);
889     ASSERT_EQ(result0, AV_ERR_OK);
890     index = aDecBufferDemo->GetInputIndex();
891     result0 = aDecBufferDemo->PushInputDataEOS(codec, index);
892     result0 = aDecBufferDemo->Start(codec);
893     ASSERT_EQ(result0, AV_ERR_INVALID_STATE);
894     result0 = aDecBufferDemo->Destroy(codec);
895     delete aDecBufferDemo;
896 }
897 
898 /**
899  * @tc.number    : STATUS_CHECK_035
900  * @tc.name      : EOS -> Running
901  * @tc.desc      : status check test
902  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_035, TestSize.Level2)903 HWTEST_F(StatusCheckTest, STATUS_CHECK_035, TestSize.Level2)
904 {
905     OH_AVCodec *codec = nullptr;
906     OH_AVFormat *format = OH_AVFormat_Create();
907     int32_t channel = 1;
908     int32_t sampleRate = 8000;  // 8000hz
909     uint32_t index;
910     OH_AVErrCode result0;
911     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
912     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
913     ASSERT_NE(codec, nullptr);
914     result0 = aDecBufferDemo->SetCallback(codec);
915     ASSERT_EQ(result0, AV_ERR_OK);
916     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
917     ASSERT_EQ(result0, AV_ERR_OK);
918     result0 = aDecBufferDemo->Start(codec);
919     ASSERT_EQ(result0, AV_ERR_OK);
920     index = aDecBufferDemo->GetInputIndex();
921     result0 = aDecBufferDemo->PushInputDataEOS(codec, index);
922     index = aDecBufferDemo->GetInputIndex();
923     result0 = aDecBufferDemo->PushInputData(codec, index);
924     ASSERT_NE(result0, AV_ERR_OK);
925     result0 = aDecBufferDemo->Destroy(codec);
926     delete aDecBufferDemo;
927 }
928 
929 /**
930  * @tc.number    : STATUS_CHECK_036
931  * @tc.name      : EOS -> EOS
932  * @tc.desc      : status check test
933  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_036, TestSize.Level2)934 HWTEST_F(StatusCheckTest, STATUS_CHECK_036, TestSize.Level2)
935 {
936     OH_AVCodec *codec = nullptr;
937     OH_AVFormat *format = OH_AVFormat_Create();
938     int32_t channel = 1;
939     int32_t sampleRate = 8000;  // 8000hz
940     uint32_t index;
941     OH_AVErrCode result0;
942     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
943     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
944     ASSERT_NE(codec, nullptr);
945     result0 = aDecBufferDemo->SetCallback(codec);
946     ASSERT_EQ(result0, AV_ERR_OK);
947     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
948     ASSERT_EQ(result0, AV_ERR_OK);
949     result0 = aDecBufferDemo->Start(codec);
950     ASSERT_EQ(result0, AV_ERR_OK);
951     index = aDecBufferDemo->GetInputIndex();
952     result0 = aDecBufferDemo->PushInputDataEOS(codec, index);
953     index = aDecBufferDemo->GetInputIndex();
954     index = -1;
955     result0 = aDecBufferDemo->PushInputDataEOS(codec, index);
956     ASSERT_NE(result0, AV_ERR_OK);
957     result0 = aDecBufferDemo->Destroy(codec);
958     delete aDecBufferDemo;
959 }
960 
961 /**
962  * @tc.number    : STATUS_CHECK_037
963  * @tc.name      : EOS -> Flush
964  * @tc.desc      : status check test
965  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_037, TestSize.Level2)966 HWTEST_F(StatusCheckTest, STATUS_CHECK_037, TestSize.Level2)
967 {
968     OH_AVCodec *codec = nullptr;
969     OH_AVFormat *format = OH_AVFormat_Create();
970     int32_t channel = 1;
971     int32_t sampleRate = 8000;  // 8000hz
972     uint32_t index;
973     OH_AVErrCode result0;
974     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
975     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
976     ASSERT_NE(codec, nullptr);
977     result0 = aDecBufferDemo->SetCallback(codec);
978     ASSERT_EQ(result0, AV_ERR_OK);
979     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
980     ASSERT_EQ(result0, AV_ERR_OK);
981     result0 = aDecBufferDemo->Start(codec);
982     ASSERT_EQ(result0, AV_ERR_OK);
983     index = aDecBufferDemo->GetInputIndex();
984     result0 = aDecBufferDemo->PushInputDataEOS(codec, index);
985     result0 = aDecBufferDemo->Flush(codec);
986     ASSERT_EQ(result0, AV_ERR_OK);
987     result0 = aDecBufferDemo->Destroy(codec);
988     delete aDecBufferDemo;
989 }
990 
991 /**
992  * @tc.number    : STATUS_CHECK_038
993  * @tc.name      : EOS -> Stop
994  * @tc.desc      : status check test
995  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_038, TestSize.Level2)996 HWTEST_F(StatusCheckTest, STATUS_CHECK_038, TestSize.Level2)
997 {
998     OH_AVCodec *codec = nullptr;
999     OH_AVFormat *format = OH_AVFormat_Create();
1000     int32_t channel = 1;
1001     int32_t sampleRate = 8000;  // 8000hz
1002     uint32_t index;
1003     OH_AVErrCode result0;
1004     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
1005     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
1006     ASSERT_NE(codec, nullptr);
1007     result0 = aDecBufferDemo->SetCallback(codec);
1008     ASSERT_EQ(result0, AV_ERR_OK);
1009     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
1010     ASSERT_EQ(result0, AV_ERR_OK);
1011     result0 = aDecBufferDemo->Start(codec);
1012     ASSERT_EQ(result0, AV_ERR_OK);
1013     index = aDecBufferDemo->GetInputIndex();
1014     result0 = aDecBufferDemo->PushInputDataEOS(codec, index);
1015     result0 = aDecBufferDemo->Stop(codec);
1016     ASSERT_EQ(result0, AV_ERR_OK);
1017     result0 = aDecBufferDemo->Destroy(codec);
1018     delete aDecBufferDemo;
1019 }
1020 
1021 /**
1022  * @tc.number    : STATUS_CHECK_039
1023  * @tc.name      : EOS -> Reset
1024  * @tc.desc      : status check test
1025  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_039, TestSize.Level2)1026 HWTEST_F(StatusCheckTest, STATUS_CHECK_039, TestSize.Level2)
1027 {
1028     OH_AVCodec *codec = nullptr;
1029     OH_AVFormat *format = OH_AVFormat_Create();
1030     int32_t channel = 1;
1031     int32_t sampleRate = 8000;  // 8000hz
1032     uint32_t index;
1033     OH_AVErrCode result0;
1034     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
1035     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
1036     ASSERT_NE(codec, nullptr);
1037     result0 = aDecBufferDemo->SetCallback(codec);
1038     ASSERT_EQ(result0, AV_ERR_OK);
1039     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
1040     ASSERT_EQ(result0, AV_ERR_OK);
1041     result0 = aDecBufferDemo->Start(codec);
1042     ASSERT_EQ(result0, AV_ERR_OK);
1043     index = aDecBufferDemo->GetInputIndex();
1044     result0 = aDecBufferDemo->PushInputDataEOS(codec, index);
1045     result0 = aDecBufferDemo->Reset(codec);
1046     ASSERT_EQ(result0, AV_ERR_OK);
1047     result0 = aDecBufferDemo->Destroy(codec);
1048     delete aDecBufferDemo;
1049 }
1050 
1051 /**
1052  * @tc.number    : STATUS_CHECK_040
1053  * @tc.name      : EOS -> Release
1054  * @tc.desc      : status check test
1055  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_040, TestSize.Level2)1056 HWTEST_F(StatusCheckTest, STATUS_CHECK_040, TestSize.Level2)
1057 {
1058     OH_AVCodec *codec = nullptr;
1059     OH_AVFormat *format = OH_AVFormat_Create();
1060     int32_t channel = 1;
1061     int32_t sampleRate = 8000;  // 8000hz
1062     uint32_t index;
1063     OH_AVErrCode result0;
1064     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
1065     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
1066     ASSERT_NE(codec, nullptr);
1067     result0 = aDecBufferDemo->SetCallback(codec);
1068     ASSERT_EQ(result0, AV_ERR_OK);
1069     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
1070     ASSERT_EQ(result0, AV_ERR_OK);
1071     result0 = aDecBufferDemo->Start(codec);
1072     ASSERT_EQ(result0, AV_ERR_OK);
1073     index = aDecBufferDemo->GetInputIndex();
1074     result0 = aDecBufferDemo->PushInputDataEOS(codec, index);
1075     result0 = aDecBufferDemo->Destroy(codec);
1076     ASSERT_EQ(result0, AV_ERR_OK);
1077     delete aDecBufferDemo;
1078 }
1079 
1080 /**
1081  * @tc.number    : STATUS_CHECK_041
1082  * @tc.name      : Flush -> Configure
1083  * @tc.desc      : status check test
1084  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_041, TestSize.Level2)1085 HWTEST_F(StatusCheckTest, STATUS_CHECK_041, TestSize.Level2)
1086 {
1087     OH_AVCodec *codec = nullptr;
1088     OH_AVFormat *format = OH_AVFormat_Create();
1089     int32_t channel = 1;
1090     int32_t sampleRate = 8000;  // 8000hz
1091     OH_AVErrCode result0;
1092     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
1093     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
1094     ASSERT_NE(codec, nullptr);
1095     result0 = aDecBufferDemo->SetCallback(codec);
1096     ASSERT_EQ(result0, AV_ERR_OK);
1097     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
1098     ASSERT_EQ(result0, AV_ERR_OK);
1099     result0 = aDecBufferDemo->Start(codec);
1100     ASSERT_EQ(result0, AV_ERR_OK);
1101     result0 = aDecBufferDemo->Flush(codec);
1102     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
1103     ASSERT_EQ(result0, AV_ERR_INVALID_STATE);
1104     result0 = aDecBufferDemo->Destroy(codec);
1105     delete aDecBufferDemo;
1106 }
1107 
1108 /**
1109  * @tc.number    : STATUS_CHECK_042
1110  * @tc.name      : Flush -> Start
1111  * @tc.desc      : status check test
1112  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_042, TestSize.Level2)1113 HWTEST_F(StatusCheckTest, STATUS_CHECK_042, TestSize.Level2)
1114 {
1115     OH_AVCodec *codec = nullptr;
1116     OH_AVFormat *format = OH_AVFormat_Create();
1117     int32_t channel = 1;
1118     int32_t sampleRate = 8000;  // 8000hz
1119     OH_AVErrCode result0;
1120     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
1121     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
1122     ASSERT_NE(codec, nullptr);
1123     result0 = aDecBufferDemo->SetCallback(codec);
1124     ASSERT_EQ(result0, AV_ERR_OK);
1125     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
1126     ASSERT_EQ(result0, AV_ERR_OK);
1127     result0 = aDecBufferDemo->Start(codec);
1128     ASSERT_EQ(result0, AV_ERR_OK);
1129     result0 = aDecBufferDemo->Flush(codec);
1130     result0 = aDecBufferDemo->Start(codec);
1131     ASSERT_EQ(result0, AV_ERR_OK);
1132     result0 = aDecBufferDemo->Destroy(codec);
1133     delete aDecBufferDemo;
1134 }
1135 
1136 /**
1137  * @tc.number    : STATUS_CHECK_043
1138  * @tc.name      : Flush -> Running
1139  * @tc.desc      : status check test
1140  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_043, TestSize.Level2)1141 HWTEST_F(StatusCheckTest, STATUS_CHECK_043, TestSize.Level2)
1142 {
1143     OH_AVCodec *codec = nullptr;
1144     OH_AVFormat *format = OH_AVFormat_Create();
1145     int32_t channel = 1;
1146     int32_t sampleRate = 8000;  // 8000hz
1147     OH_AVErrCode result0;
1148     uint32_t index;
1149     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
1150     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
1151     ASSERT_NE(codec, nullptr);
1152     result0 = aDecBufferDemo->SetCallback(codec);
1153     ASSERT_EQ(result0, AV_ERR_OK);
1154     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
1155     ASSERT_EQ(result0, AV_ERR_OK);
1156     result0 = aDecBufferDemo->Start(codec);
1157     ASSERT_EQ(result0, AV_ERR_OK);
1158     result0 = aDecBufferDemo->Flush(codec);
1159     index = aDecBufferDemo->GetInputIndex();
1160     result0 = aDecBufferDemo->PushInputData(codec, index);
1161     ASSERT_EQ(result0, AV_ERR_INVALID_STATE);
1162     result0 = aDecBufferDemo->Destroy(codec);
1163     delete aDecBufferDemo;
1164 }
1165 
1166 /**
1167  * @tc.number    : STATUS_CHECK_044
1168  * @tc.name      : Flush -> EOS
1169  * @tc.desc      : status check test
1170  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_044, TestSize.Level2)1171 HWTEST_F(StatusCheckTest, STATUS_CHECK_044, TestSize.Level2)
1172 {
1173     OH_AVCodec *codec = nullptr;
1174     OH_AVFormat *format = OH_AVFormat_Create();
1175     int32_t channel = 1;
1176     int32_t sampleRate = 8000;  // 8000hz
1177     OH_AVErrCode result0;
1178     uint32_t index;
1179     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
1180     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
1181     ASSERT_NE(codec, nullptr);
1182     result0 = aDecBufferDemo->SetCallback(codec);
1183     ASSERT_EQ(result0, AV_ERR_OK);
1184     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
1185     ASSERT_EQ(result0, AV_ERR_OK);
1186     result0 = aDecBufferDemo->Start(codec);
1187     ASSERT_EQ(result0, AV_ERR_OK);
1188     result0 = aDecBufferDemo->Flush(codec);
1189     index = aDecBufferDemo->GetInputIndex();
1190     result0 = aDecBufferDemo->PushInputDataEOS(codec, index);
1191     ASSERT_NE(result0, AV_ERR_OK);
1192     result0 = aDecBufferDemo->Destroy(codec);
1193     delete aDecBufferDemo;
1194 }
1195 
1196 /**
1197  * @tc.number    : STATUS_CHECK_045
1198  * @tc.name      : Flush -> Flush
1199  * @tc.desc      : status check test
1200  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_045, TestSize.Level2)1201 HWTEST_F(StatusCheckTest, STATUS_CHECK_045, TestSize.Level2)
1202 {
1203     OH_AVCodec *codec = nullptr;
1204     OH_AVFormat *format = OH_AVFormat_Create();
1205     int32_t channel = 1;
1206     int32_t sampleRate = 8000;  // 8000hz
1207     OH_AVErrCode result0;
1208     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
1209     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
1210     ASSERT_NE(codec, nullptr);
1211     result0 = aDecBufferDemo->SetCallback(codec);
1212     ASSERT_EQ(result0, AV_ERR_OK);
1213     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
1214     ASSERT_EQ(result0, AV_ERR_OK);
1215     result0 = aDecBufferDemo->Start(codec);
1216     ASSERT_EQ(result0, AV_ERR_OK);
1217     result0 = aDecBufferDemo->Flush(codec);
1218     result0 = aDecBufferDemo->Flush(codec);
1219     ASSERT_EQ(result0, AV_ERR_INVALID_STATE);
1220     result0 = aDecBufferDemo->Destroy(codec);
1221     delete aDecBufferDemo;
1222 }
1223 
1224 /**
1225  * @tc.number    : STATUS_CHECK_046
1226  * @tc.name      : Flush -> Stop
1227  * @tc.desc      : status check test
1228  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_046, TestSize.Level2)1229 HWTEST_F(StatusCheckTest, STATUS_CHECK_046, TestSize.Level2)
1230 {
1231     OH_AVCodec *codec = nullptr;
1232     OH_AVFormat *format = OH_AVFormat_Create();
1233     int32_t channel = 1;
1234     int32_t sampleRate = 8000;  // 8000hz
1235     OH_AVErrCode result0;
1236     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
1237     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
1238     ASSERT_NE(codec, nullptr);
1239     result0 = aDecBufferDemo->SetCallback(codec);
1240     ASSERT_EQ(result0, AV_ERR_OK);
1241     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
1242     ASSERT_EQ(result0, AV_ERR_OK);
1243     result0 = aDecBufferDemo->Start(codec);
1244     ASSERT_EQ(result0, AV_ERR_OK);
1245     result0 = aDecBufferDemo->Flush(codec);
1246     result0 = aDecBufferDemo->Stop(codec);
1247     ASSERT_EQ(result0, AV_ERR_OK);
1248     result0 = aDecBufferDemo->Destroy(codec);
1249     delete aDecBufferDemo;
1250 }
1251 
1252 /**
1253  * @tc.number    : STATUS_CHECK_047
1254  * @tc.name      : Flush -> Reset
1255  * @tc.desc      : status check test
1256  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_047, TestSize.Level2)1257 HWTEST_F(StatusCheckTest, STATUS_CHECK_047, TestSize.Level2)
1258 {
1259     OH_AVCodec *codec = nullptr;
1260     OH_AVFormat *format = OH_AVFormat_Create();
1261     int32_t channel = 1;
1262     int32_t sampleRate = 8000;  // 8000hz
1263     OH_AVErrCode result0;
1264     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
1265     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
1266     ASSERT_NE(codec, nullptr);
1267     result0 = aDecBufferDemo->SetCallback(codec);
1268     ASSERT_EQ(result0, AV_ERR_OK);
1269     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
1270     ASSERT_EQ(result0, AV_ERR_OK);
1271     result0 = aDecBufferDemo->Start(codec);
1272     ASSERT_EQ(result0, AV_ERR_OK);
1273     result0 = aDecBufferDemo->Flush(codec);
1274     result0 = aDecBufferDemo->Reset(codec);
1275     ASSERT_EQ(result0, AV_ERR_OK);
1276     result0 = aDecBufferDemo->Destroy(codec);
1277     delete aDecBufferDemo;
1278 }
1279 
1280 /**
1281  * @tc.number    : STATUS_CHECK_048
1282  * @tc.name      : Flush -> Release
1283  * @tc.desc      : status check test
1284  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_048, TestSize.Level2)1285 HWTEST_F(StatusCheckTest, STATUS_CHECK_048, TestSize.Level2)
1286 {
1287     OH_AVCodec *codec = nullptr;
1288     OH_AVFormat *format = OH_AVFormat_Create();
1289     int32_t channel = 1;
1290     int32_t sampleRate = 8000;  // 8000hz
1291     OH_AVErrCode result0;
1292     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
1293     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
1294     ASSERT_NE(codec, nullptr);
1295     result0 = aDecBufferDemo->SetCallback(codec);
1296     ASSERT_EQ(result0, AV_ERR_OK);
1297     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
1298     ASSERT_EQ(result0, AV_ERR_OK);
1299     result0 = aDecBufferDemo->Start(codec);
1300     ASSERT_EQ(result0, AV_ERR_OK);
1301     result0 = aDecBufferDemo->Flush(codec);
1302     result0 = aDecBufferDemo->Destroy(codec);
1303     ASSERT_EQ(result0, AV_ERR_OK);
1304     delete aDecBufferDemo;
1305 }
1306 
1307 /**
1308  * @tc.number    : STATUS_CHECK_049
1309  * @tc.name      : Stop -> Configure
1310  * @tc.desc      : status check test
1311  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_049, TestSize.Level2)1312 HWTEST_F(StatusCheckTest, STATUS_CHECK_049, TestSize.Level2)
1313 {
1314     OH_AVCodec *codec = nullptr;
1315     OH_AVFormat *format = OH_AVFormat_Create();
1316     int32_t channel = 1;
1317     int32_t sampleRate = 8000;  // 8000hz
1318     OH_AVErrCode result0;
1319     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
1320     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
1321     ASSERT_NE(codec, nullptr);
1322     result0 = aDecBufferDemo->SetCallback(codec);
1323     ASSERT_EQ(result0, AV_ERR_OK);
1324     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
1325     ASSERT_EQ(result0, AV_ERR_OK);
1326     result0 = aDecBufferDemo->Start(codec);
1327     ASSERT_EQ(result0, AV_ERR_OK);
1328     result0 = aDecBufferDemo->Stop(codec);
1329     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
1330     ASSERT_EQ(result0, AV_ERR_INVALID_STATE);
1331     result0 = aDecBufferDemo->Destroy(codec);
1332     delete aDecBufferDemo;
1333 }
1334 
1335 /**
1336  * @tc.number    : STATUS_CHECK_050
1337  * @tc.name      : Stop -> Start
1338  * @tc.desc      : status check test
1339  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_050, TestSize.Level2)1340 HWTEST_F(StatusCheckTest, STATUS_CHECK_050, TestSize.Level2)
1341 {
1342     OH_AVCodec *codec = nullptr;
1343     OH_AVFormat *format = OH_AVFormat_Create();
1344     int32_t channel = 1;
1345     int32_t sampleRate = 8000;  // 8000hz
1346     OH_AVErrCode result0;
1347     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
1348     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
1349     ASSERT_NE(codec, nullptr);
1350     result0 = aDecBufferDemo->SetCallback(codec);
1351     ASSERT_EQ(result0, AV_ERR_OK);
1352     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
1353     ASSERT_EQ(result0, AV_ERR_OK);
1354     result0 = aDecBufferDemo->Start(codec);
1355     ASSERT_EQ(result0, AV_ERR_OK);
1356     result0 = aDecBufferDemo->Stop(codec);
1357     result0 = aDecBufferDemo->Start(codec);
1358     ASSERT_EQ(result0, AV_ERR_OK);
1359     result0 = aDecBufferDemo->Destroy(codec);
1360     delete aDecBufferDemo;
1361 }
1362 
1363 /**
1364  * @tc.number    : STATUS_CHECK_051
1365  * @tc.name      : Stop -> Running
1366  * @tc.desc      : status check test
1367  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_051, TestSize.Level2)1368 HWTEST_F(StatusCheckTest, STATUS_CHECK_051, TestSize.Level2)
1369 {
1370     OH_AVCodec *codec = nullptr;
1371     OH_AVFormat *format = OH_AVFormat_Create();
1372     int32_t channel = 1;
1373     int32_t sampleRate = 8000;  // 8000hz
1374     OH_AVErrCode result0;
1375     uint32_t index;
1376     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
1377     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
1378     ASSERT_NE(codec, nullptr);
1379     result0 = aDecBufferDemo->SetCallback(codec);
1380     ASSERT_EQ(result0, AV_ERR_OK);
1381     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
1382     ASSERT_EQ(result0, AV_ERR_OK);
1383     result0 = aDecBufferDemo->Start(codec);
1384     ASSERT_EQ(result0, AV_ERR_OK);
1385     result0 = aDecBufferDemo->Stop(codec);
1386     index = aDecBufferDemo->GetInputIndex();
1387     result0 = aDecBufferDemo->PushInputData(codec, index);
1388     ASSERT_EQ(result0, AV_ERR_INVALID_STATE);
1389     result0 = aDecBufferDemo->Destroy(codec);
1390     delete aDecBufferDemo;
1391 }
1392 
1393 /**
1394  * @tc.number    : STATUS_CHECK_052
1395  * @tc.name      : Stop -> EOS
1396  * @tc.desc      : status check test
1397  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_052, TestSize.Level2)1398 HWTEST_F(StatusCheckTest, STATUS_CHECK_052, TestSize.Level2)
1399 {
1400     OH_AVCodec *codec = nullptr;
1401     OH_AVFormat *format = OH_AVFormat_Create();
1402     int32_t channel = 1;
1403     int32_t sampleRate = 8000;  // 8000hz
1404     OH_AVErrCode result0;
1405     uint32_t index;
1406     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
1407     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
1408     ASSERT_NE(codec, nullptr);
1409     result0 = aDecBufferDemo->SetCallback(codec);
1410     ASSERT_EQ(result0, AV_ERR_OK);
1411     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
1412     ASSERT_EQ(result0, AV_ERR_OK);
1413     result0 = aDecBufferDemo->Start(codec);
1414     ASSERT_EQ(result0, AV_ERR_OK);
1415     result0 = aDecBufferDemo->Stop(codec);
1416     index = aDecBufferDemo->GetInputIndex();
1417     result0 = aDecBufferDemo->PushInputDataEOS(codec, index);
1418     ASSERT_NE(result0, AV_ERR_OK);
1419     result0 = aDecBufferDemo->Destroy(codec);
1420     delete aDecBufferDemo;
1421 }
1422 
1423 /**
1424  * @tc.number    : STATUS_CHECK_053
1425  * @tc.name      : Stop -> Flush
1426  * @tc.desc      : status check test
1427  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_053, TestSize.Level2)1428 HWTEST_F(StatusCheckTest, STATUS_CHECK_053, TestSize.Level2)
1429 {
1430     OH_AVCodec *codec = nullptr;
1431     OH_AVFormat *format = OH_AVFormat_Create();
1432     int32_t channel = 1;
1433     int32_t sampleRate = 8000;  // 8000hz
1434     OH_AVErrCode result0;
1435     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
1436     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
1437     ASSERT_NE(codec, nullptr);
1438     result0 = aDecBufferDemo->SetCallback(codec);
1439     ASSERT_EQ(result0, AV_ERR_OK);
1440     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
1441     ASSERT_EQ(result0, AV_ERR_OK);
1442     result0 = aDecBufferDemo->Start(codec);
1443     ASSERT_EQ(result0, AV_ERR_OK);
1444     result0 = aDecBufferDemo->Stop(codec);
1445     result0 = aDecBufferDemo->Flush(codec);
1446     ASSERT_EQ(result0, AV_ERR_INVALID_STATE);
1447     result0 = aDecBufferDemo->Destroy(codec);
1448     delete aDecBufferDemo;
1449 }
1450 
1451 /**
1452  * @tc.number    : STATUS_CHECK_054
1453  * @tc.name      : Stop -> Stop
1454  * @tc.desc      : status check test
1455  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_054, TestSize.Level2)1456 HWTEST_F(StatusCheckTest, STATUS_CHECK_054, TestSize.Level2)
1457 {
1458     OH_AVCodec *codec = nullptr;
1459     OH_AVFormat *format = OH_AVFormat_Create();
1460     int32_t channel = 1;
1461     int32_t sampleRate = 8000;  // 8000hz
1462     OH_AVErrCode result0;
1463     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
1464     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
1465     ASSERT_NE(codec, nullptr);
1466     result0 = aDecBufferDemo->SetCallback(codec);
1467     ASSERT_EQ(result0, AV_ERR_OK);
1468     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
1469     ASSERT_EQ(result0, AV_ERR_OK);
1470     result0 = aDecBufferDemo->Start(codec);
1471     ASSERT_EQ(result0, AV_ERR_OK);
1472     result0 = aDecBufferDemo->Stop(codec);
1473     result0 = aDecBufferDemo->Stop(codec);
1474     ASSERT_EQ(result0, AV_ERR_INVALID_STATE);
1475     result0 = aDecBufferDemo->Destroy(codec);
1476     delete aDecBufferDemo;
1477 }
1478 
1479 /**
1480  * @tc.number    : STATUS_CHECK_055
1481  * @tc.name      : Stop -> Reset
1482  * @tc.desc      : status check test
1483  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_055, TestSize.Level2)1484 HWTEST_F(StatusCheckTest, STATUS_CHECK_055, TestSize.Level2)
1485 {
1486     OH_AVCodec *codec = nullptr;
1487     OH_AVFormat *format = OH_AVFormat_Create();
1488     int32_t channel = 1;
1489     int32_t sampleRate = 8000;  // 8000hz
1490     OH_AVErrCode result0;
1491     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
1492     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
1493     ASSERT_NE(codec, nullptr);
1494     result0 = aDecBufferDemo->SetCallback(codec);
1495     ASSERT_EQ(result0, AV_ERR_OK);
1496     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
1497     ASSERT_EQ(result0, AV_ERR_OK);
1498     result0 = aDecBufferDemo->Start(codec);
1499     ASSERT_EQ(result0, AV_ERR_OK);
1500     result0 = aDecBufferDemo->Stop(codec);
1501     result0 = aDecBufferDemo->Reset(codec);
1502     ASSERT_EQ(result0, AV_ERR_OK);
1503     result0 = aDecBufferDemo->Destroy(codec);
1504     delete aDecBufferDemo;
1505 }
1506 
1507 /**
1508  * @tc.number    : STATUS_CHECK_056
1509  * @tc.name      : Stop -> Release
1510  * @tc.desc      : status check test
1511  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_056, TestSize.Level2)1512 HWTEST_F(StatusCheckTest, STATUS_CHECK_056, TestSize.Level2)
1513 {
1514     OH_AVCodec *codec = nullptr;
1515     OH_AVFormat *format = OH_AVFormat_Create();
1516     int32_t channel = 1;
1517     int32_t sampleRate = 8000;  // 8000hz
1518     OH_AVErrCode result0;
1519     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
1520     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
1521     ASSERT_NE(codec, nullptr);
1522     result0 = aDecBufferDemo->SetCallback(codec);
1523     ASSERT_EQ(result0, AV_ERR_OK);
1524     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
1525     ASSERT_EQ(result0, AV_ERR_OK);
1526     result0 = aDecBufferDemo->Start(codec);
1527     ASSERT_EQ(result0, AV_ERR_OK);
1528     result0 = aDecBufferDemo->Stop(codec);
1529     result0 = aDecBufferDemo->Destroy(codec);
1530     ASSERT_EQ(result0, AV_ERR_OK);
1531     delete aDecBufferDemo;
1532 }
1533 
1534 /**
1535  * @tc.number    : STATUS_CHECK_057
1536  * @tc.name      : Reset -> Configure
1537  * @tc.desc      : status check test
1538  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_057, TestSize.Level2)1539 HWTEST_F(StatusCheckTest, STATUS_CHECK_057, TestSize.Level2)
1540 {
1541     OH_AVCodec *codec = nullptr;
1542     OH_AVErrCode result0;
1543     OH_AVFormat *format = OH_AVFormat_Create();
1544     int32_t channel = 1;
1545     int32_t sampleRate = 8000;  // 8000hz
1546     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
1547     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
1548     ASSERT_NE(codec, nullptr);
1549     result0 = aDecBufferDemo->Reset(codec);
1550     result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
1551     ASSERT_EQ(result0, AV_ERR_OK);
1552     result0 = aDecBufferDemo->Destroy(codec);
1553     delete aDecBufferDemo;
1554 }
1555 
1556 /**
1557  * @tc.number    : STATUS_CHECK_058
1558  * @tc.name      : Reset -> Start
1559  * @tc.desc      : status check test
1560  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_058, TestSize.Level2)1561 HWTEST_F(StatusCheckTest, STATUS_CHECK_058, TestSize.Level2)
1562 {
1563     OH_AVCodec *codec = nullptr;
1564     OH_AVErrCode result0;
1565     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
1566     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
1567     ASSERT_NE(codec, nullptr);
1568     result0 = aDecBufferDemo->Reset(codec);
1569     result0 = aDecBufferDemo->Start(codec);
1570     ASSERT_EQ(result0, AV_ERR_INVALID_STATE);
1571     result0 = aDecBufferDemo->Destroy(codec);
1572     delete aDecBufferDemo;
1573 }
1574 
1575 /**
1576  * @tc.number    : STATUS_CHECK_059
1577  * @tc.name      : Reset -> Running
1578  * @tc.desc      : status check test
1579  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_059, TestSize.Level2)1580 HWTEST_F(StatusCheckTest, STATUS_CHECK_059, TestSize.Level2)
1581 {
1582     OH_AVCodec *codec = nullptr;
1583     OH_AVErrCode result0;
1584     uint32_t index;
1585     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
1586     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
1587     ASSERT_NE(codec, nullptr);
1588     result0 = aDecBufferDemo->Reset(codec);
1589     index = aDecBufferDemo->GetInputIndex();
1590     result0 = aDecBufferDemo->PushInputData(codec, index);
1591     ASSERT_EQ(result0, AV_ERR_INVALID_STATE);
1592     result0 = aDecBufferDemo->Destroy(codec);
1593     delete aDecBufferDemo;
1594 }
1595 
1596 /**
1597  * @tc.number    : STATUS_CHECK_060
1598  * @tc.name      : Reset -> EOS
1599  * @tc.desc      : status check test
1600  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_060, TestSize.Level2)1601 HWTEST_F(StatusCheckTest, STATUS_CHECK_060, TestSize.Level2)
1602 {
1603     OH_AVCodec *codec = nullptr;
1604     OH_AVErrCode result0;
1605     uint32_t index;
1606     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
1607     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
1608     ASSERT_NE(codec, nullptr);
1609     result0 = aDecBufferDemo->Reset(codec);
1610     index = aDecBufferDemo->GetInputIndex();
1611     result0 = aDecBufferDemo->PushInputDataEOS(codec, index);
1612     ASSERT_NE(result0, AV_ERR_OK);
1613     result0 = aDecBufferDemo->Destroy(codec);
1614     delete aDecBufferDemo;
1615 }
1616 
1617 /**
1618  * @tc.number    : STATUS_CHECK_061
1619  * @tc.name      : Reset -> Flush
1620  * @tc.desc      : status check test
1621  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_061, TestSize.Level2)1622 HWTEST_F(StatusCheckTest, STATUS_CHECK_061, TestSize.Level2)
1623 {
1624     OH_AVCodec *codec = nullptr;
1625     OH_AVErrCode result0;
1626     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
1627     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
1628     ASSERT_NE(codec, nullptr);
1629     result0 = aDecBufferDemo->Reset(codec);
1630     result0 = aDecBufferDemo->Flush(codec);
1631     ASSERT_EQ(result0, AV_ERR_INVALID_STATE);
1632     result0 = aDecBufferDemo->Destroy(codec);
1633     delete aDecBufferDemo;
1634 }
1635 
1636 /**
1637  * @tc.number    : STATUS_CHECK_062
1638  * @tc.name      : Reset -> Stop
1639  * @tc.desc      : status check test
1640  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_062, TestSize.Level2)1641 HWTEST_F(StatusCheckTest, STATUS_CHECK_062, TestSize.Level2)
1642 {
1643     OH_AVCodec *codec = nullptr;
1644     OH_AVErrCode result0;
1645     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
1646     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
1647     ASSERT_NE(codec, nullptr);
1648     result0 = aDecBufferDemo->Reset(codec);
1649     result0 = aDecBufferDemo->Stop(codec);
1650     ASSERT_EQ(result0, AV_ERR_INVALID_STATE);
1651     result0 = aDecBufferDemo->Destroy(codec);
1652     delete aDecBufferDemo;
1653 }
1654 
1655 /**
1656  * @tc.number    : STATUS_CHECK_063
1657  * @tc.name      : Reset -> Reset
1658  * @tc.desc      : status check test
1659  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_063, TestSize.Level2)1660 HWTEST_F(StatusCheckTest, STATUS_CHECK_063, TestSize.Level2)
1661 {
1662     OH_AVCodec *codec = nullptr;
1663     OH_AVErrCode result0;
1664     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
1665     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
1666     ASSERT_NE(codec, nullptr);
1667     result0 = aDecBufferDemo->Reset(codec);
1668     result0 = aDecBufferDemo->Reset(codec);
1669     ASSERT_EQ(result0, AV_ERR_OK);
1670     result0 = aDecBufferDemo->Destroy(codec);
1671     delete aDecBufferDemo;
1672 }
1673 
1674 /**
1675  * @tc.number    : STATUS_CHECK_064
1676  * @tc.name      : Reset -> Release
1677  * @tc.desc      : status check test
1678  */
HWTEST_F(StatusCheckTest, STATUS_CHECK_064, TestSize.Level2)1679 HWTEST_F(StatusCheckTest, STATUS_CHECK_064, TestSize.Level2)
1680 {
1681     OH_AVCodec *codec = nullptr;
1682     OH_AVErrCode result0;
1683     ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
1684     codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
1685     ASSERT_NE(codec, nullptr);
1686     result0 = aDecBufferDemo->Reset(codec);
1687     result0 = aDecBufferDemo->Destroy(codec);
1688     ASSERT_EQ(result0, AV_ERR_OK);
1689     delete aDecBufferDemo;
1690 }
1691