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