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