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 
25 using namespace std;
26 using namespace testing::ext;
27 using namespace OHOS;
28 using namespace OHOS::MediaAVCodec;
29 
30 namespace {
31 class InnerInterfaceDependCheckTest : public testing::Test {
32 public:
33     static void SetUpTestCase();
34     static void TearDownTestCase();
35     void SetUp() override;
36     void TearDown() override;
37 };
38 
SetUpTestCase()39 void InnerInterfaceDependCheckTest::SetUpTestCase() {}
TearDownTestCase()40 void InnerInterfaceDependCheckTest::TearDownTestCase() {}
SetUp()41 void InnerInterfaceDependCheckTest::SetUp() {}
TearDown()42 void InnerInterfaceDependCheckTest::TearDown() {}
43 
44 constexpr int32_t CHANNEL_COUNT = 1;
45 constexpr int32_t SAMPLE_RATE = 48000;
46 constexpr int64_t BITS_RATE = 320000;
47 constexpr int32_t BITS_PER_CODED_SAMPLE = 24;
48 constexpr int32_t DEFAULT_SIZE = 100;
49 
Create(AudioDecoderDemo * decoderDemo)50 int32_t Create(AudioDecoderDemo *decoderDemo)
51 {
52     return decoderDemo->InnerCreateByName("OH.Media.Codec.Decoder.Audio.Mpeg");
53 }
54 
SetCallback(AudioDecoderDemo * decoderDemo,std::shared_ptr<InnerADecDemoCallback> cb_)55 int32_t SetCallback(AudioDecoderDemo *decoderDemo, std::shared_ptr<InnerADecDemoCallback> cb_)
56 {
57     return decoderDemo->InnerSetCallback(cb_);
58 }
59 
Configure(AudioDecoderDemo * decoderDemo)60 int32_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 
Prepare(AudioDecoderDemo * decoderDemo)71 int32_t Prepare(AudioDecoderDemo *decoderDemo)
72 {
73     return decoderDemo->InnerPrepare();
74 }
75 
Start(AudioDecoderDemo * decoderDemo)76 int32_t Start(AudioDecoderDemo *decoderDemo)
77 {
78     return decoderDemo->InnerStart();
79 }
80 
Flush(AudioDecoderDemo * decoderDemo)81 int32_t Flush(AudioDecoderDemo *decoderDemo)
82 {
83     return decoderDemo->InnerFlush();
84 }
85 
Reset(AudioDecoderDemo * decoderDemo)86 int32_t Reset(AudioDecoderDemo *decoderDemo)
87 {
88     return decoderDemo->InnerReset();
89 }
90 
GetInputIndex(AudioDecoderDemo * decoderDemo)91 uint32_t GetInputIndex(AudioDecoderDemo *decoderDemo)
92 {
93     return decoderDemo->NativeGetInputIndex();
94 }
95 
QueueInputBuffer(AudioDecoderDemo * decoderDemo,uint32_t index)96 int32_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 
Stop(AudioDecoderDemo * decoderDemo)109 int32_t Stop(AudioDecoderDemo *decoderDemo)
110 {
111     return decoderDemo->InnerStop();
112 }
113 
Destroy(AudioDecoderDemo * decoderDemo)114 int32_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  */
125 HWTEST_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  */
150 HWTEST_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  */
178 HWTEST_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  */
209 HWTEST_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  */
243 HWTEST_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  */
281 HWTEST_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  */
318 HWTEST_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  */
355 HWTEST_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  */
395 HWTEST_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  */
420 HWTEST_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  */
451 HWTEST_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  */
485 HWTEST_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  */
523 HWTEST_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  */
560 HWTEST_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  */
597 HWTEST_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  */
637 HWTEST_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  */
662 HWTEST_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  */
693 HWTEST_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  */
731 HWTEST_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_OK, 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  */
768 HWTEST_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  */
805 HWTEST_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  */
845 HWTEST_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  */
870 HWTEST_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_OK, 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  */
901 HWTEST_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  */
939 HWTEST_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  */
976 HWTEST_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_OK, 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  */
1013 HWTEST_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  */
1053 HWTEST_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  */
1078 HWTEST_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  */
1110 HWTEST_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  */
1144 HWTEST_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  */
1181 HWTEST_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  */
1220 HWTEST_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  */
1257 HWTEST_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  */
1297 HWTEST_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  */
1321 HWTEST_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  */
1351 HWTEST_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  */
1383 HWTEST_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  */
1420 HWTEST_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  */
1455 HWTEST_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  */
1490 HWTEST_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  */
1528 HWTEST_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  */
1553 HWTEST_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  */
1585 HWTEST_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  */
1620 HWTEST_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  */
1659 HWTEST_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  */
1697 HWTEST_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  */
1738 HWTEST_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  */
1776 HWTEST_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  */
1817 HWTEST_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  */
1856 HWTEST_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  */
1892 HWTEST_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  */
1930 HWTEST_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  */
1971 HWTEST_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  */
2009 HWTEST_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