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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 ASSERT_EQ(result0, AV_ERR_OK);
332 result0 = aDecBufferDemo->Stop(codec);
333 ASSERT_EQ(result0, AV_ERR_OK);
334 result0 = aDecBufferDemo->Destroy(codec);
335 delete aDecBufferDemo;
336 }
337
338 /**
339 * @tc.number : STATUS_CHECK_015
340 * @tc.name : Configure -> Reset
341 * @tc.desc : status check test
342 */
343 HWTEST_F(StatusCheckTest, STATUS_CHECK_015, TestSize.Level2)
344 {
345 OH_AVCodec *codec = nullptr;
346 OH_AVFormat *format = OH_AVFormat_Create();
347 int32_t channel = 1;
348 int32_t sampleRate = 8000; // 8000hz
349 OH_AVErrCode result0;
350 ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
351 codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
352 ASSERT_NE(codec, nullptr);
353 result0 = aDecBufferDemo->SetCallback(codec);
354 ASSERT_EQ(result0, AV_ERR_OK);
355 result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
356 result0 = aDecBufferDemo->Reset(codec);
357 ASSERT_EQ(result0, AV_ERR_OK);
358 result0 = aDecBufferDemo->Destroy(codec);
359 delete aDecBufferDemo;
360 }
361
362 /**
363 * @tc.number : STATUS_CHECK_016
364 * @tc.name : Configure -> Release
365 * @tc.desc : status check test
366 */
367 HWTEST_F(StatusCheckTest, STATUS_CHECK_016, TestSize.Level2)
368 {
369 OH_AVCodec *codec = nullptr;
370 OH_AVFormat *format = OH_AVFormat_Create();
371 int32_t channel = 1;
372 int32_t sampleRate = 8000; // 8000hz
373 OH_AVErrCode result0;
374 ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
375 codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
376 ASSERT_NE(codec, nullptr);
377 result0 = aDecBufferDemo->SetCallback(codec);
378 ASSERT_EQ(result0, AV_ERR_OK);
379 result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
380 result0 = aDecBufferDemo->Destroy(codec);
381 ASSERT_EQ(result0, AV_ERR_OK);
382 delete aDecBufferDemo;
383 }
384
385 /**
386 * @tc.number : STATUS_CHECK_017
387 * @tc.name : Start -> Configure
388 * @tc.desc : status check test
389 */
390 HWTEST_F(StatusCheckTest, STATUS_CHECK_017, TestSize.Level2)
391 {
392 OH_AVCodec *codec = nullptr;
393 OH_AVFormat *format = OH_AVFormat_Create();
394 int32_t channel = 1;
395 int32_t sampleRate = 8000; // 8000hz
396 OH_AVErrCode result0;
397 ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
398 codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
399 ASSERT_NE(codec, nullptr);
400 result0 = aDecBufferDemo->SetCallback(codec);
401 ASSERT_EQ(result0, AV_ERR_OK);
402 result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
403 ASSERT_EQ(result0, AV_ERR_OK);
404 result0 = aDecBufferDemo->Start(codec);
405 result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
406 ASSERT_EQ(result0, AV_ERR_INVALID_STATE);
407 result0 = aDecBufferDemo->Destroy(codec);
408 delete aDecBufferDemo;
409 }
410
411 /**
412 * @tc.number : STATUS_CHECK_018
413 * @tc.name : Start -> Start
414 * @tc.desc : status check test
415 */
416 HWTEST_F(StatusCheckTest, STATUS_CHECK_018, TestSize.Level2)
417 {
418 OH_AVCodec *codec = nullptr;
419 OH_AVFormat *format = OH_AVFormat_Create();
420 int32_t channel = 1;
421 int32_t sampleRate = 8000; // 8000hz
422 OH_AVErrCode result0;
423 ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
424 codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
425 ASSERT_NE(codec, nullptr);
426 result0 = aDecBufferDemo->SetCallback(codec);
427 ASSERT_EQ(result0, AV_ERR_OK);
428 result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
429 ASSERT_EQ(result0, AV_ERR_OK);
430 result0 = aDecBufferDemo->Start(codec);
431 result0 = aDecBufferDemo->Start(codec);
432 ASSERT_EQ(result0, AV_ERR_INVALID_STATE);
433 result0 = aDecBufferDemo->Destroy(codec);
434 delete aDecBufferDemo;
435 }
436
437 /**
438 * @tc.number : STATUS_CHECK_019
439 * @tc.name : Start -> Running
440 * @tc.desc : status check test
441 */
442 HWTEST_F(StatusCheckTest, STATUS_CHECK_019, TestSize.Level2)
443 {
444 OH_AVCodec *codec = nullptr;
445 OH_AVFormat *format = OH_AVFormat_Create();
446 int32_t channel = 1;
447 int32_t sampleRate = 8000; // 8000hz
448 OH_AVErrCode result0;
449 uint32_t index;
450 ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
451 codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
452 ASSERT_NE(codec, nullptr);
453 result0 = aDecBufferDemo->SetCallback(codec);
454 ASSERT_EQ(result0, AV_ERR_OK);
455 result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
456 ASSERT_EQ(result0, AV_ERR_OK);
457 result0 = aDecBufferDemo->Start(codec);
458 index = aDecBufferDemo->GetInputIndex();
459 result0 = aDecBufferDemo->PushInputData(codec, index);
460 ASSERT_EQ(result0, AV_ERR_UNKNOWN);
461 result0 = aDecBufferDemo->Destroy(codec);
462 delete aDecBufferDemo;
463 }
464
465 /**
466 * @tc.number : STATUS_CHECK_020
467 * @tc.name : Start -> EOS
468 * @tc.desc : status check test
469 */
470 HWTEST_F(StatusCheckTest, STATUS_CHECK_020, TestSize.Level2)
471 {
472 OH_AVCodec *codec = nullptr;
473 OH_AVFormat *format = OH_AVFormat_Create();
474 int32_t channel = 1;
475 int32_t sampleRate = 8000; // 8000hz
476 OH_AVErrCode result0;
477 uint32_t index;
478 ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
479 codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
480 ASSERT_NE(codec, nullptr);
481 result0 = aDecBufferDemo->SetCallback(codec);
482 ASSERT_EQ(result0, AV_ERR_OK);
483 result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
484 ASSERT_EQ(result0, AV_ERR_OK);
485 result0 = aDecBufferDemo->Start(codec);
486 index = aDecBufferDemo->GetInputIndex();
487 index = -1;
488 result0 = aDecBufferDemo->PushInputDataEOS(codec, index);
489 ASSERT_NE(result0, AV_ERR_OK);
490 result0 = aDecBufferDemo->Destroy(codec);
491 delete aDecBufferDemo;
492 }
493
494 /**
495 * @tc.number : STATUS_CHECK_021
496 * @tc.name : Start -> Flush
497 * @tc.desc : status check test
498 */
499 HWTEST_F(StatusCheckTest, STATUS_CHECK_021, TestSize.Level2)
500 {
501 OH_AVCodec *codec = nullptr;
502 OH_AVFormat *format = OH_AVFormat_Create();
503 int32_t channel = 1;
504 int32_t sampleRate = 8000; // 8000hz
505 OH_AVErrCode result0;
506 ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
507 codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
508 ASSERT_NE(codec, nullptr);
509 result0 = aDecBufferDemo->SetCallback(codec);
510 ASSERT_EQ(result0, AV_ERR_OK);
511 result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
512 ASSERT_EQ(result0, AV_ERR_OK);
513 result0 = aDecBufferDemo->Start(codec);
514 result0 = aDecBufferDemo->Flush(codec);
515 ASSERT_EQ(result0, AV_ERR_OK);
516 result0 = aDecBufferDemo->Destroy(codec);
517 delete aDecBufferDemo;
518 }
519
520 /**
521 * @tc.number : STATUS_CHECK_022
522 * @tc.name : Start -> Stop
523 * @tc.desc : status check test
524 */
525 HWTEST_F(StatusCheckTest, STATUS_CHECK_022, TestSize.Level2)
526 {
527 OH_AVCodec *codec = nullptr;
528 OH_AVFormat *format = OH_AVFormat_Create();
529 int32_t channel = 1;
530 int32_t sampleRate = 8000; // 8000hz
531 OH_AVErrCode result0;
532 ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
533 codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
534 ASSERT_NE(codec, nullptr);
535 result0 = aDecBufferDemo->SetCallback(codec);
536 ASSERT_EQ(result0, AV_ERR_OK);
537 result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
538 ASSERT_EQ(result0, AV_ERR_OK);
539 result0 = aDecBufferDemo->Start(codec);
540 result0 = aDecBufferDemo->Stop(codec);
541 ASSERT_EQ(result0, AV_ERR_OK);
542 result0 = aDecBufferDemo->Destroy(codec);
543 delete aDecBufferDemo;
544 }
545
546 /**
547 * @tc.number : STATUS_CHECK_023
548 * @tc.name : Start -> Reset
549 * @tc.desc : status check test
550 */
551 HWTEST_F(StatusCheckTest, STATUS_CHECK_023, TestSize.Level2)
552 {
553 OH_AVCodec *codec = nullptr;
554 OH_AVFormat *format = OH_AVFormat_Create();
555 int32_t channel = 1;
556 int32_t sampleRate = 8000; // 8000hz
557 OH_AVErrCode result0;
558 ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
559 codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
560 ASSERT_NE(codec, nullptr);
561 result0 = aDecBufferDemo->SetCallback(codec);
562 ASSERT_EQ(result0, AV_ERR_OK);
563 result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
564 ASSERT_EQ(result0, AV_ERR_OK);
565 result0 = aDecBufferDemo->Start(codec);
566 result0 = aDecBufferDemo->Reset(codec);
567 ASSERT_EQ(result0, AV_ERR_OK);
568 result0 = aDecBufferDemo->Destroy(codec);
569 delete aDecBufferDemo;
570 }
571
572 /**
573 * @tc.number : STATUS_CHECK_024
574 * @tc.name : Start -> Release
575 * @tc.desc : status check test
576 */
577 HWTEST_F(StatusCheckTest, STATUS_CHECK_024, TestSize.Level2)
578 {
579 OH_AVCodec *codec = nullptr;
580 OH_AVFormat *format = OH_AVFormat_Create();
581 int32_t channel = 1;
582 int32_t sampleRate = 8000; // 8000hz
583 OH_AVErrCode result0;
584 ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
585 codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
586 ASSERT_NE(codec, nullptr);
587 result0 = aDecBufferDemo->SetCallback(codec);
588 ASSERT_EQ(result0, AV_ERR_OK);
589 result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
590 ASSERT_EQ(result0, AV_ERR_OK);
591 result0 = aDecBufferDemo->Start(codec);
592 result0 = aDecBufferDemo->Destroy(codec);
593 ASSERT_EQ(result0, AV_ERR_OK);
594 delete aDecBufferDemo;
595 }
596
597 /**
598 * @tc.number : STATUS_CHECK_025
599 * @tc.name : Running -> Configure
600 * @tc.desc : status check test
601 */
602 HWTEST_F(StatusCheckTest, STATUS_CHECK_025, TestSize.Level2)
603 {
604 OH_AVCodec *codec = nullptr;
605 OH_AVFormat *format = OH_AVFormat_Create();
606 int32_t channel = 1;
607 int32_t sampleRate = 8000; // 8000hz
608 uint32_t index;
609 OH_AVErrCode result0;
610 ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
611 codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
612 ASSERT_NE(codec, nullptr);
613 result0 = aDecBufferDemo->SetCallback(codec);
614 ASSERT_EQ(result0, AV_ERR_OK);
615 result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
616 ASSERT_EQ(result0, AV_ERR_OK);
617 result0 = aDecBufferDemo->Start(codec);
618 ASSERT_EQ(result0, AV_ERR_OK);
619 index = aDecBufferDemo->GetInputIndex();
620 result0 = aDecBufferDemo->PushInputData(codec, index);
621 result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
622 ASSERT_EQ(result0, AV_ERR_INVALID_STATE);
623 result0 = aDecBufferDemo->Destroy(codec);
624 delete aDecBufferDemo;
625 }
626
627 /**
628 * @tc.number : STATUS_CHECK_026
629 * @tc.name : Running -> Start
630 * @tc.desc : status check test
631 */
632 HWTEST_F(StatusCheckTest, STATUS_CHECK_026, TestSize.Level2)
633 {
634 OH_AVCodec *codec = nullptr;
635 OH_AVFormat *format = OH_AVFormat_Create();
636 int32_t channel = 1;
637 int32_t sampleRate = 8000; // 8000hz
638 uint32_t index;
639 OH_AVErrCode result0;
640 ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
641 codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
642 ASSERT_NE(codec, nullptr);
643 result0 = aDecBufferDemo->SetCallback(codec);
644 ASSERT_EQ(result0, AV_ERR_OK);
645 result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
646 ASSERT_EQ(result0, AV_ERR_OK);
647 result0 = aDecBufferDemo->Start(codec);
648 ASSERT_EQ(result0, AV_ERR_OK);
649 index = aDecBufferDemo->GetInputIndex();
650 result0 = aDecBufferDemo->PushInputData(codec, index);
651 result0 = aDecBufferDemo->Start(codec);
652 ASSERT_EQ(result0, AV_ERR_INVALID_STATE);
653 result0 = aDecBufferDemo->Destroy(codec);
654 delete aDecBufferDemo;
655 }
656
657 /**
658 * @tc.number : STATUS_CHECK_027
659 * @tc.name : Running -> Running
660 * @tc.desc : status check test
661 */
662 HWTEST_F(StatusCheckTest, STATUS_CHECK_027, TestSize.Level2)
663 {
664 OH_AVCodec *codec = nullptr;
665 OH_AVFormat *format = OH_AVFormat_Create();
666 int32_t channel = 1;
667 int32_t sampleRate = 8000; // 8000hz
668 uint32_t index;
669 OH_AVErrCode result0;
670 ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
671 codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
672 ASSERT_NE(codec, nullptr);
673 result0 = aDecBufferDemo->SetCallback(codec);
674 ASSERT_EQ(result0, AV_ERR_OK);
675 result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
676 ASSERT_EQ(result0, AV_ERR_OK);
677 result0 = aDecBufferDemo->Start(codec);
678 ASSERT_EQ(result0, AV_ERR_OK);
679 index = aDecBufferDemo->GetInputIndex();
680 result0 = aDecBufferDemo->PushInputData(codec, index);
681 result0 = aDecBufferDemo->PushInputData(codec, index);
682 ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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_NE(result0, AV_ERR_OK);
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 */
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 */
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 ASSERT_EQ(result0, AV_ERR_OK);
1219 result0 = aDecBufferDemo->Flush(codec);
1220 ASSERT_EQ(result0, AV_ERR_OK);
1221 result0 = aDecBufferDemo->Destroy(codec);
1222 delete aDecBufferDemo;
1223 }
1224
1225 /**
1226 * @tc.number : STATUS_CHECK_046
1227 * @tc.name : Flush -> Stop
1228 * @tc.desc : status check test
1229 */
1230 HWTEST_F(StatusCheckTest, STATUS_CHECK_046, TestSize.Level2)
1231 {
1232 OH_AVCodec *codec = nullptr;
1233 OH_AVFormat *format = OH_AVFormat_Create();
1234 int32_t channel = 1;
1235 int32_t sampleRate = 8000; // 8000hz
1236 OH_AVErrCode result0;
1237 ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
1238 codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
1239 ASSERT_NE(codec, nullptr);
1240 result0 = aDecBufferDemo->SetCallback(codec);
1241 ASSERT_EQ(result0, AV_ERR_OK);
1242 result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
1243 ASSERT_EQ(result0, AV_ERR_OK);
1244 result0 = aDecBufferDemo->Start(codec);
1245 ASSERT_EQ(result0, AV_ERR_OK);
1246 result0 = aDecBufferDemo->Flush(codec);
1247 result0 = aDecBufferDemo->Stop(codec);
1248 ASSERT_EQ(result0, AV_ERR_OK);
1249 result0 = aDecBufferDemo->Destroy(codec);
1250 delete aDecBufferDemo;
1251 }
1252
1253 /**
1254 * @tc.number : STATUS_CHECK_047
1255 * @tc.name : Flush -> Reset
1256 * @tc.desc : status check test
1257 */
1258 HWTEST_F(StatusCheckTest, STATUS_CHECK_047, TestSize.Level2)
1259 {
1260 OH_AVCodec *codec = nullptr;
1261 OH_AVFormat *format = OH_AVFormat_Create();
1262 int32_t channel = 1;
1263 int32_t sampleRate = 8000; // 8000hz
1264 OH_AVErrCode result0;
1265 ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
1266 codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
1267 ASSERT_NE(codec, nullptr);
1268 result0 = aDecBufferDemo->SetCallback(codec);
1269 ASSERT_EQ(result0, AV_ERR_OK);
1270 result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
1271 ASSERT_EQ(result0, AV_ERR_OK);
1272 result0 = aDecBufferDemo->Start(codec);
1273 ASSERT_EQ(result0, AV_ERR_OK);
1274 result0 = aDecBufferDemo->Flush(codec);
1275 result0 = aDecBufferDemo->Reset(codec);
1276 ASSERT_EQ(result0, AV_ERR_OK);
1277 result0 = aDecBufferDemo->Destroy(codec);
1278 delete aDecBufferDemo;
1279 }
1280
1281 /**
1282 * @tc.number : STATUS_CHECK_048
1283 * @tc.name : Flush -> Release
1284 * @tc.desc : status check test
1285 */
1286 HWTEST_F(StatusCheckTest, STATUS_CHECK_048, TestSize.Level2)
1287 {
1288 OH_AVCodec *codec = nullptr;
1289 OH_AVFormat *format = OH_AVFormat_Create();
1290 int32_t channel = 1;
1291 int32_t sampleRate = 8000; // 8000hz
1292 OH_AVErrCode result0;
1293 ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
1294 codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
1295 ASSERT_NE(codec, nullptr);
1296 result0 = aDecBufferDemo->SetCallback(codec);
1297 ASSERT_EQ(result0, AV_ERR_OK);
1298 result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
1299 ASSERT_EQ(result0, AV_ERR_OK);
1300 result0 = aDecBufferDemo->Start(codec);
1301 ASSERT_EQ(result0, AV_ERR_OK);
1302 result0 = aDecBufferDemo->Flush(codec);
1303 result0 = aDecBufferDemo->Destroy(codec);
1304 ASSERT_EQ(result0, AV_ERR_OK);
1305 delete aDecBufferDemo;
1306 }
1307
1308 /**
1309 * @tc.number : STATUS_CHECK_049
1310 * @tc.name : Stop -> Configure
1311 * @tc.desc : status check test
1312 */
1313 HWTEST_F(StatusCheckTest, STATUS_CHECK_049, TestSize.Level2)
1314 {
1315 OH_AVCodec *codec = nullptr;
1316 OH_AVFormat *format = OH_AVFormat_Create();
1317 int32_t channel = 1;
1318 int32_t sampleRate = 8000; // 8000hz
1319 OH_AVErrCode result0;
1320 ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
1321 codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
1322 ASSERT_NE(codec, nullptr);
1323 result0 = aDecBufferDemo->SetCallback(codec);
1324 ASSERT_EQ(result0, AV_ERR_OK);
1325 result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
1326 ASSERT_EQ(result0, AV_ERR_OK);
1327 result0 = aDecBufferDemo->Start(codec);
1328 ASSERT_EQ(result0, AV_ERR_OK);
1329 result0 = aDecBufferDemo->Stop(codec);
1330 result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
1331 ASSERT_EQ(result0, AV_ERR_INVALID_STATE);
1332 result0 = aDecBufferDemo->Destroy(codec);
1333 delete aDecBufferDemo;
1334 }
1335
1336 /**
1337 * @tc.number : STATUS_CHECK_050
1338 * @tc.name : Stop -> Start
1339 * @tc.desc : status check test
1340 */
1341 HWTEST_F(StatusCheckTest, STATUS_CHECK_050, TestSize.Level2)
1342 {
1343 OH_AVCodec *codec = nullptr;
1344 OH_AVFormat *format = OH_AVFormat_Create();
1345 int32_t channel = 1;
1346 int32_t sampleRate = 8000; // 8000hz
1347 OH_AVErrCode result0;
1348 ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
1349 codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
1350 ASSERT_NE(codec, nullptr);
1351 result0 = aDecBufferDemo->SetCallback(codec);
1352 ASSERT_EQ(result0, AV_ERR_OK);
1353 result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
1354 ASSERT_EQ(result0, AV_ERR_OK);
1355 result0 = aDecBufferDemo->Start(codec);
1356 ASSERT_EQ(result0, AV_ERR_OK);
1357 result0 = aDecBufferDemo->Stop(codec);
1358 result0 = aDecBufferDemo->Start(codec);
1359 ASSERT_EQ(result0, AV_ERR_OK);
1360 result0 = aDecBufferDemo->Destroy(codec);
1361 delete aDecBufferDemo;
1362 }
1363
1364 /**
1365 * @tc.number : STATUS_CHECK_051
1366 * @tc.name : Stop -> Running
1367 * @tc.desc : status check test
1368 */
1369 HWTEST_F(StatusCheckTest, STATUS_CHECK_051, TestSize.Level2)
1370 {
1371 OH_AVCodec *codec = nullptr;
1372 OH_AVFormat *format = OH_AVFormat_Create();
1373 int32_t channel = 1;
1374 int32_t sampleRate = 8000; // 8000hz
1375 OH_AVErrCode result0;
1376 uint32_t index;
1377 ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
1378 codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
1379 ASSERT_NE(codec, nullptr);
1380 result0 = aDecBufferDemo->SetCallback(codec);
1381 ASSERT_EQ(result0, AV_ERR_OK);
1382 result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
1383 ASSERT_EQ(result0, AV_ERR_OK);
1384 result0 = aDecBufferDemo->Start(codec);
1385 ASSERT_EQ(result0, AV_ERR_OK);
1386 result0 = aDecBufferDemo->Stop(codec);
1387 index = aDecBufferDemo->GetInputIndex();
1388 result0 = aDecBufferDemo->PushInputData(codec, index);
1389 ASSERT_NE(result0, AV_ERR_OK);
1390 result0 = aDecBufferDemo->Destroy(codec);
1391 delete aDecBufferDemo;
1392 }
1393
1394 /**
1395 * @tc.number : STATUS_CHECK_052
1396 * @tc.name : Stop -> EOS
1397 * @tc.desc : status check test
1398 */
1399 HWTEST_F(StatusCheckTest, STATUS_CHECK_052, TestSize.Level2)
1400 {
1401 OH_AVCodec *codec = nullptr;
1402 OH_AVFormat *format = OH_AVFormat_Create();
1403 int32_t channel = 1;
1404 int32_t sampleRate = 8000; // 8000hz
1405 OH_AVErrCode result0;
1406 uint32_t index;
1407 ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
1408 codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
1409 ASSERT_NE(codec, nullptr);
1410 result0 = aDecBufferDemo->SetCallback(codec);
1411 ASSERT_EQ(result0, AV_ERR_OK);
1412 result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
1413 ASSERT_EQ(result0, AV_ERR_OK);
1414 result0 = aDecBufferDemo->Start(codec);
1415 ASSERT_EQ(result0, AV_ERR_OK);
1416 result0 = aDecBufferDemo->Stop(codec);
1417 index = aDecBufferDemo->GetInputIndex();
1418 result0 = aDecBufferDemo->PushInputDataEOS(codec, index);
1419 ASSERT_NE(result0, AV_ERR_OK);
1420 result0 = aDecBufferDemo->Destroy(codec);
1421 delete aDecBufferDemo;
1422 }
1423
1424 /**
1425 * @tc.number : STATUS_CHECK_053
1426 * @tc.name : Stop -> Flush
1427 * @tc.desc : status check test
1428 */
1429 HWTEST_F(StatusCheckTest, STATUS_CHECK_053, TestSize.Level2)
1430 {
1431 OH_AVCodec *codec = nullptr;
1432 OH_AVFormat *format = OH_AVFormat_Create();
1433 int32_t channel = 1;
1434 int32_t sampleRate = 8000; // 8000hz
1435 OH_AVErrCode result0;
1436 ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
1437 codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
1438 ASSERT_NE(codec, nullptr);
1439 result0 = aDecBufferDemo->SetCallback(codec);
1440 ASSERT_EQ(result0, AV_ERR_OK);
1441 result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
1442 ASSERT_EQ(result0, AV_ERR_OK);
1443 result0 = aDecBufferDemo->Start(codec);
1444 ASSERT_EQ(result0, AV_ERR_OK);
1445 result0 = aDecBufferDemo->Stop(codec);
1446 result0 = aDecBufferDemo->Flush(codec);
1447 ASSERT_EQ(result0, AV_ERR_INVALID_STATE);
1448 result0 = aDecBufferDemo->Destroy(codec);
1449 delete aDecBufferDemo;
1450 }
1451
1452 /**
1453 * @tc.number : STATUS_CHECK_054
1454 * @tc.name : Stop -> Stop
1455 * @tc.desc : status check test
1456 */
1457 HWTEST_F(StatusCheckTest, STATUS_CHECK_054, TestSize.Level2)
1458 {
1459 OH_AVCodec *codec = nullptr;
1460 OH_AVFormat *format = OH_AVFormat_Create();
1461 int32_t channel = 1;
1462 int32_t sampleRate = 8000; // 8000hz
1463 OH_AVErrCode result0;
1464 ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
1465 codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
1466 ASSERT_NE(codec, nullptr);
1467 result0 = aDecBufferDemo->SetCallback(codec);
1468 ASSERT_EQ(result0, AV_ERR_OK);
1469 result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
1470 ASSERT_EQ(result0, AV_ERR_OK);
1471 result0 = aDecBufferDemo->Start(codec);
1472 ASSERT_EQ(result0, AV_ERR_OK);
1473 result0 = aDecBufferDemo->Stop(codec);
1474 ASSERT_EQ(result0, AV_ERR_OK);
1475 result0 = aDecBufferDemo->Stop(codec);
1476 ASSERT_EQ(result0, AV_ERR_OK);
1477 result0 = aDecBufferDemo->Destroy(codec);
1478 delete aDecBufferDemo;
1479 }
1480
1481 /**
1482 * @tc.number : STATUS_CHECK_055
1483 * @tc.name : Stop -> Reset
1484 * @tc.desc : status check test
1485 */
1486 HWTEST_F(StatusCheckTest, STATUS_CHECK_055, TestSize.Level2)
1487 {
1488 OH_AVCodec *codec = nullptr;
1489 OH_AVFormat *format = OH_AVFormat_Create();
1490 int32_t channel = 1;
1491 int32_t sampleRate = 8000; // 8000hz
1492 OH_AVErrCode result0;
1493 ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
1494 codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
1495 ASSERT_NE(codec, nullptr);
1496 result0 = aDecBufferDemo->SetCallback(codec);
1497 ASSERT_EQ(result0, AV_ERR_OK);
1498 result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
1499 ASSERT_EQ(result0, AV_ERR_OK);
1500 result0 = aDecBufferDemo->Start(codec);
1501 ASSERT_EQ(result0, AV_ERR_OK);
1502 result0 = aDecBufferDemo->Stop(codec);
1503 result0 = aDecBufferDemo->Reset(codec);
1504 ASSERT_EQ(result0, AV_ERR_OK);
1505 result0 = aDecBufferDemo->Destroy(codec);
1506 delete aDecBufferDemo;
1507 }
1508
1509 /**
1510 * @tc.number : STATUS_CHECK_056
1511 * @tc.name : Stop -> Release
1512 * @tc.desc : status check test
1513 */
1514 HWTEST_F(StatusCheckTest, STATUS_CHECK_056, TestSize.Level2)
1515 {
1516 OH_AVCodec *codec = nullptr;
1517 OH_AVFormat *format = OH_AVFormat_Create();
1518 int32_t channel = 1;
1519 int32_t sampleRate = 8000; // 8000hz
1520 OH_AVErrCode result0;
1521 ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
1522 codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
1523 ASSERT_NE(codec, nullptr);
1524 result0 = aDecBufferDemo->SetCallback(codec);
1525 ASSERT_EQ(result0, AV_ERR_OK);
1526 result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
1527 ASSERT_EQ(result0, AV_ERR_OK);
1528 result0 = aDecBufferDemo->Start(codec);
1529 ASSERT_EQ(result0, AV_ERR_OK);
1530 result0 = aDecBufferDemo->Stop(codec);
1531 result0 = aDecBufferDemo->Destroy(codec);
1532 ASSERT_EQ(result0, AV_ERR_OK);
1533 delete aDecBufferDemo;
1534 }
1535
1536 /**
1537 * @tc.number : STATUS_CHECK_057
1538 * @tc.name : Reset -> Configure
1539 * @tc.desc : status check test
1540 */
1541 HWTEST_F(StatusCheckTest, STATUS_CHECK_057, TestSize.Level2)
1542 {
1543 OH_AVCodec *codec = nullptr;
1544 OH_AVErrCode result0;
1545 OH_AVFormat *format = OH_AVFormat_Create();
1546 int32_t channel = 1;
1547 int32_t sampleRate = 8000; // 8000hz
1548 ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
1549 codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
1550 ASSERT_NE(codec, nullptr);
1551 result0 = aDecBufferDemo->Reset(codec);
1552 result0 = aDecBufferDemo->Configure(codec, format, channel, sampleRate);
1553 ASSERT_EQ(result0, AV_ERR_OK);
1554 result0 = aDecBufferDemo->Destroy(codec);
1555 delete aDecBufferDemo;
1556 }
1557
1558 /**
1559 * @tc.number : STATUS_CHECK_058
1560 * @tc.name : Reset -> Start
1561 * @tc.desc : status check test
1562 */
1563 HWTEST_F(StatusCheckTest, STATUS_CHECK_058, TestSize.Level2)
1564 {
1565 OH_AVCodec *codec = nullptr;
1566 OH_AVErrCode result0;
1567 ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
1568 codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
1569 ASSERT_NE(codec, nullptr);
1570 result0 = aDecBufferDemo->Reset(codec);
1571 result0 = aDecBufferDemo->Start(codec);
1572 ASSERT_EQ(result0, AV_ERR_INVALID_STATE);
1573 result0 = aDecBufferDemo->Destroy(codec);
1574 delete aDecBufferDemo;
1575 }
1576
1577 /**
1578 * @tc.number : STATUS_CHECK_059
1579 * @tc.name : Reset -> Running
1580 * @tc.desc : status check test
1581 */
1582 HWTEST_F(StatusCheckTest, STATUS_CHECK_059, TestSize.Level2)
1583 {
1584 OH_AVCodec *codec = nullptr;
1585 OH_AVErrCode result0;
1586 uint32_t index;
1587 ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
1588 codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
1589 ASSERT_NE(codec, nullptr);
1590 result0 = aDecBufferDemo->Reset(codec);
1591 index = aDecBufferDemo->GetInputIndex();
1592 result0 = aDecBufferDemo->PushInputData(codec, index);
1593 ASSERT_EQ(result0, AV_ERR_INVALID_STATE);
1594 result0 = aDecBufferDemo->Destroy(codec);
1595 delete aDecBufferDemo;
1596 }
1597
1598 /**
1599 * @tc.number : STATUS_CHECK_060
1600 * @tc.name : Reset -> EOS
1601 * @tc.desc : status check test
1602 */
1603 HWTEST_F(StatusCheckTest, STATUS_CHECK_060, TestSize.Level2)
1604 {
1605 OH_AVCodec *codec = nullptr;
1606 OH_AVErrCode result0;
1607 uint32_t index;
1608 ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
1609 codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
1610 ASSERT_NE(codec, nullptr);
1611 result0 = aDecBufferDemo->Reset(codec);
1612 index = aDecBufferDemo->GetInputIndex();
1613 result0 = aDecBufferDemo->PushInputDataEOS(codec, index);
1614 ASSERT_NE(result0, AV_ERR_OK);
1615 result0 = aDecBufferDemo->Destroy(codec);
1616 delete aDecBufferDemo;
1617 }
1618
1619 /**
1620 * @tc.number : STATUS_CHECK_061
1621 * @tc.name : Reset -> Flush
1622 * @tc.desc : status check test
1623 */
1624 HWTEST_F(StatusCheckTest, STATUS_CHECK_061, TestSize.Level2)
1625 {
1626 OH_AVCodec *codec = nullptr;
1627 OH_AVErrCode result0;
1628 ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
1629 codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
1630 ASSERT_NE(codec, nullptr);
1631 result0 = aDecBufferDemo->Reset(codec);
1632 result0 = aDecBufferDemo->Flush(codec);
1633 ASSERT_EQ(result0, AV_ERR_INVALID_STATE);
1634 result0 = aDecBufferDemo->Destroy(codec);
1635 delete aDecBufferDemo;
1636 }
1637
1638 /**
1639 * @tc.number : STATUS_CHECK_062
1640 * @tc.name : Reset -> Stop
1641 * @tc.desc : status check test
1642 */
1643 HWTEST_F(StatusCheckTest, STATUS_CHECK_062, TestSize.Level2)
1644 {
1645 OH_AVCodec *codec = nullptr;
1646 OH_AVErrCode result0;
1647 ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
1648 codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
1649 ASSERT_NE(codec, nullptr);
1650 result0 = aDecBufferDemo->Reset(codec);
1651 result0 = aDecBufferDemo->Stop(codec);
1652 ASSERT_EQ(result0, AV_ERR_INVALID_STATE);
1653 result0 = aDecBufferDemo->Destroy(codec);
1654 delete aDecBufferDemo;
1655 }
1656
1657 /**
1658 * @tc.number : STATUS_CHECK_063
1659 * @tc.name : Reset -> Reset
1660 * @tc.desc : status check test
1661 */
1662 HWTEST_F(StatusCheckTest, STATUS_CHECK_063, TestSize.Level2)
1663 {
1664 OH_AVCodec *codec = nullptr;
1665 OH_AVErrCode result0;
1666 ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
1667 codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
1668 ASSERT_NE(codec, nullptr);
1669 result0 = aDecBufferDemo->Reset(codec);
1670 result0 = aDecBufferDemo->Reset(codec);
1671 ASSERT_EQ(result0, AV_ERR_OK);
1672 result0 = aDecBufferDemo->Destroy(codec);
1673 delete aDecBufferDemo;
1674 }
1675
1676 /**
1677 * @tc.number : STATUS_CHECK_064
1678 * @tc.name : Reset -> Release
1679 * @tc.desc : status check test
1680 */
1681 HWTEST_F(StatusCheckTest, STATUS_CHECK_064, TestSize.Level2)
1682 {
1683 OH_AVCodec *codec = nullptr;
1684 OH_AVErrCode result0;
1685 ADecBufferDemo *aDecBufferDemo = new ADecBufferDemo();
1686 codec = aDecBufferDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
1687 ASSERT_NE(codec, nullptr);
1688 result0 = aDecBufferDemo->Reset(codec);
1689 result0 = aDecBufferDemo->Destroy(codec);
1690 ASSERT_EQ(result0, AV_ERR_OK);
1691 delete aDecBufferDemo;
1692 }
1693