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
26using namespace std;
27using namespace testing::ext;
28using namespace OHOS;
29using namespace OHOS::MediaAVCodec;
30constexpr uint32_t SIZE_NUM = 100;
31constexpr uint32_t SAMPLE_RATE_44100 = 44100;
32constexpr uint32_t SAMPLE_RATE_112000 = 112000;
33
34namespace {
35class InnerInterfaceDependCheckTest : public testing::Test {
36public:
37    static void SetUpTestCase();
38    static void TearDownTestCase();
39    void SetUp() override;
40    void TearDown() override;
41};
42
43void InnerInterfaceDependCheckTest::SetUpTestCase() {}
44void InnerInterfaceDependCheckTest::TearDownTestCase() {}
45void InnerInterfaceDependCheckTest::SetUp() {}
46void InnerInterfaceDependCheckTest::TearDown() {}
47
48int32_t Create(AudioEncoderDemo *encoderDemo)
49{
50    return encoderDemo->InnerCreateByName("OH.Media.Codec.Encoder.Audio.AAC");
51}
52
53int32_t SetCallback(AudioEncoderDemo *encoderDemo, const std::shared_ptr<AVCodecCallback> &cb_)
54{
55    return encoderDemo->InnerSetCallback(cb_);
56}
57int32_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
70int32_t Prepare(AudioEncoderDemo *encoderDemo)
71{
72    return encoderDemo->InnerPrepare();
73}
74
75int32_t Start(AudioEncoderDemo *encoderDemo)
76{
77    int32_t ret = encoderDemo->InnerStartWithThread();
78    sleep(1);
79    return ret;
80}
81
82int32_t Flush(AudioEncoderDemo *encoderDemo)
83{
84    return encoderDemo->InnerFlush();
85}
86
87int32_t Reset(AudioEncoderDemo *encoderDemo)
88{
89    return encoderDemo->InnerReset();
90}
91
92int32_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
103int32_t Stop(AudioEncoderDemo *encoderDemo)
104{
105    return encoderDemo->InnerStop();
106}
107
108int32_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 */
119HWTEST_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 */
143HWTEST_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 */
170HWTEST_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 */
200HWTEST_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 */
233HWTEST_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 */
271HWTEST_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 */
307HWTEST_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 */
343HWTEST_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 */
382HWTEST_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 */
407HWTEST_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 */
437HWTEST_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 */
470HWTEST_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 */
508HWTEST_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 */
544HWTEST_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 */
580HWTEST_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 */
619HWTEST_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 */
643HWTEST_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 */
673HWTEST_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 */
711HWTEST_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_INVALID_STATE, 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 */
747HWTEST_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 */
783HWTEST_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 */
822HWTEST_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 */
846HWTEST_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_INVALID_STATE, 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 */
876HWTEST_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 */
914HWTEST_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 */
950HWTEST_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_INVALID_STATE, 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 */
986HWTEST_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 */
1025HWTEST_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 */
1049HWTEST_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 */
1079HWTEST_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 */
1112HWTEST_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 */
1148HWTEST_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 */
1186HWTEST_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 */
1222HWTEST_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 */
1261HWTEST_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 */
1284HWTEST_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 */
1313HWTEST_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 */
1344HWTEST_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 */
1380HWTEST_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 */
1414HWTEST_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 */
1448HWTEST_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 */
1485HWTEST_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 */
1510HWTEST_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 */
1541HWTEST_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 */
1575HWTEST_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 */
1613HWTEST_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 */
1650HWTEST_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 */
1690HWTEST_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 */
1727HWTEST_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