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