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