1/*
2 * Copyright (C) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 *     http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16#include <string>
17#include "gtest/gtest.h"
18#include "AudioEncoderDemoCommon.h"
19
20using namespace std;
21using namespace testing::ext;
22using namespace OHOS;
23using namespace OHOS::MediaAVCodec;
24
25namespace {
26class NativeInterfaceDependCheckTest : public testing::Test {
27public:
28    static void SetUpTestCase();
29    static void TearDownTestCase();
30    void SetUp() override;
31    void TearDown() override;
32};
33
34void NativeInterfaceDependCheckTest::SetUpTestCase() {}
35void NativeInterfaceDependCheckTest::TearDownTestCase() {}
36void NativeInterfaceDependCheckTest::SetUp() {}
37void NativeInterfaceDependCheckTest::TearDown() {}
38
39OH_AVCodec *Create(AudioEncoderDemo *encoderDemo)
40{
41    return encoderDemo->NativeCreateByName("OH.Media.Codec.Encoder.Audio.AAC");
42}
43
44OH_AVErrCode Destroy(AudioEncoderDemo *encoderDemo, OH_AVCodec *handle)
45{
46    return encoderDemo->NativeDestroy(handle);
47}
48
49OH_AVErrCode SetCallback(AudioEncoderDemo *encoderDemo, OH_AVCodec *handle)
50{
51    struct OH_AVCodecAsyncCallback cb = {&OnError, &OnOutputFormatChanged, &OnInputBufferAvailable,
52                                         &OnOutputBufferAvailable};
53    return encoderDemo->NativeSetCallback(handle, cb);
54}
55
56OH_AVErrCode Configure(AudioEncoderDemo *encoderDemo, OH_AVCodec *handle)
57{
58    constexpr uint32_t CHANNEL_COUNT = 2;
59    constexpr uint32_t SAMPLE_RATE = 44100;
60    constexpr uint32_t BITS_RATE = 169000;
61    OH_AVFormat *format = OH_AVFormat_Create();
62    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, CHANNEL_COUNT);
63    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, SAMPLE_RATE);
64    OH_AVFormat_SetIntValue(format, OH_MD_KEY_BITS_PER_CODED_SAMPLE, OH_BitsPerSample::SAMPLE_F32LE);
65    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, OH_BitsPerSample::SAMPLE_F32LE);
66    OH_AVFormat_SetLongValue(format, OH_MD_KEY_CHANNEL_LAYOUT, STEREO);
67    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AAC_IS_ADTS, 1);
68    OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, BITS_RATE);
69
70    OH_AVErrCode ret = encoderDemo->NativeConfigure(handle, format);
71
72    OH_AVFormat_Destroy(format);
73    return ret;
74}
75
76OH_AVErrCode Prepare(AudioEncoderDemo *encoderDemo, OH_AVCodec *handle)
77{
78    return encoderDemo->NativePrepare(handle);
79}
80
81OH_AVErrCode Start(AudioEncoderDemo *encoderDemo, OH_AVCodec *handle, uint32_t &index, uint8_t *data)
82{
83    OH_AVErrCode ret = encoderDemo->NativeStart(handle);
84    if (ret != AV_ERR_OK) {
85        return ret;
86    }
87
88    sleep(1);
89    index = encoderDemo->NativeGetInputIndex();
90    data = encoderDemo->NativeGetInputBuf();
91
92    return ret;
93}
94
95OH_AVErrCode Stop(AudioEncoderDemo *encoderDemo, OH_AVCodec *handle)
96{
97    return encoderDemo->NativeStop(handle);
98}
99
100OH_AVErrCode Flush(AudioEncoderDemo *encoderDemo, OH_AVCodec *handle)
101{
102    return encoderDemo->NativeFlush(handle);
103}
104
105OH_AVErrCode Reset(AudioEncoderDemo *encoderDemo, OH_AVCodec *handle)
106{
107    return encoderDemo->NativeReset(handle);
108}
109
110OH_AVErrCode PushInputData(AudioEncoderDemo *encoderDemo, OH_AVCodec *handle, uint32_t index)
111{
112    OH_AVCodecBufferAttr info;
113    constexpr uint32_t INFO_SIZE = 100;
114    info.size = INFO_SIZE;
115    info.offset = 0;
116    info.pts = 0;
117    info.flags = AVCODEC_BUFFER_FLAGS_NONE;
118
119    return encoderDemo->NativePushInputData(handle, index, info);
120}
121
122OH_AVErrCode PushInputDataEOS(AudioEncoderDemo *encoderDemo, OH_AVCodec *handle, uint32_t index)
123{
124    OH_AVCodecBufferAttr info;
125    info.size = 0;
126    info.offset = 0;
127    info.pts = 0;
128    info.flags = AVCODEC_BUFFER_FLAGS_EOS;
129
130    return encoderDemo->NativePushInputData(handle, index, info);
131}
132} // namespace
133
134/**
135 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_001
136 * @tc.name      : Create -> SetCallback
137 * @tc.desc      : interface depend check
138 */
139HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_001, TestSize.Level2)
140{
141    OH_AVErrCode ret;
142    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
143    OH_AVCodec *handle = Create(encoderDemo);
144    ASSERT_NE(nullptr, handle);
145
146    ret = SetCallback(encoderDemo, handle);
147    ASSERT_EQ(AV_ERR_OK, ret);
148
149    Destroy(encoderDemo, handle);
150    delete encoderDemo;
151}
152
153/**
154 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_002
155 * @tc.name      : Create -> SetCallback -> SetCallback
156 * @tc.desc      : interface depend check
157 */
158HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_002, TestSize.Level2)
159{
160    OH_AVErrCode ret;
161    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
162    OH_AVCodec *handle = Create(encoderDemo);
163    ASSERT_NE(nullptr, handle);
164
165    ret = SetCallback(encoderDemo, handle);
166    ASSERT_EQ(AV_ERR_OK, ret);
167
168    ret = SetCallback(encoderDemo, handle);
169    ASSERT_EQ(AV_ERR_OK, ret);
170
171    Destroy(encoderDemo, handle);
172    delete encoderDemo;
173}
174
175/**
176 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_003
177 * @tc.name      : Create -> Configure -> SetCallback
178 * @tc.desc      : interface depend check
179 */
180HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_003, TestSize.Level2)
181{
182    OH_AVErrCode ret;
183    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
184    OH_AVCodec *handle = Create(encoderDemo);
185    ASSERT_NE(nullptr, handle);
186
187    ret = Configure(encoderDemo, handle);
188    ASSERT_EQ(AV_ERR_OK, ret);
189
190    ret = SetCallback(encoderDemo, handle);
191    ASSERT_EQ(AV_ERR_OK, ret);
192
193    Destroy(encoderDemo, handle);
194    delete encoderDemo;
195}
196
197/**
198 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_004
199 * @tc.name      : Create -> SetCallback -> Configure -> Prepare -> SetCallback
200 * @tc.desc      : interface depend check
201 */
202HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_004, TestSize.Level2)
203{
204    OH_AVErrCode ret;
205    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
206    OH_AVCodec *handle = Create(encoderDemo);
207    ASSERT_NE(nullptr, handle);
208
209    ret = SetCallback(encoderDemo, handle);
210    ASSERT_EQ(AV_ERR_OK, ret);
211
212    ret = Configure(encoderDemo, handle);
213    ASSERT_EQ(AV_ERR_OK, ret);
214
215    ret = Prepare(encoderDemo, handle);
216    ASSERT_EQ(AV_ERR_OK, ret);
217
218    ret = SetCallback(encoderDemo, handle);
219    ASSERT_EQ(AV_ERR_OK, ret);
220
221    Destroy(encoderDemo, handle);
222    delete encoderDemo;
223}
224
225/**
226 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_005
227 * @tc.name      : Create -> SetCallback -> Configure -> Prepare -> Start -> SetCallback
228 * @tc.desc      : interface depend check
229 */
230HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_005, TestSize.Level2)
231{
232    OH_AVErrCode ret;
233    uint32_t trackId = -1;
234    uint8_t *data = nullptr;
235
236    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
237    OH_AVCodec *handle = Create(encoderDemo);
238    cout << "handle is " << handle << endl;
239    ASSERT_NE(nullptr, handle);
240
241    ret = SetCallback(encoderDemo, handle);
242    cout << "SetCallback ret is " << ret << endl;
243    ASSERT_EQ(AV_ERR_OK, ret);
244
245    ret = Configure(encoderDemo, handle);
246    cout << "Configure ret is " << ret << endl;
247    ASSERT_EQ(AV_ERR_OK, ret);
248
249    ret = Prepare(encoderDemo, handle);
250    cout << "Prepare ret is " << ret << endl;
251    ASSERT_EQ(AV_ERR_OK, ret);
252
253    ret = Start(encoderDemo, handle, trackId, data);
254    cout << "Start ret is " << ret << endl;
255    ASSERT_EQ(AV_ERR_OK, ret);
256
257    ret = SetCallback(encoderDemo, handle);
258    cout << "SetCallback ret is " << ret << endl;
259    ASSERT_EQ(AV_ERR_OK, ret);
260
261    Destroy(encoderDemo, handle);
262    delete encoderDemo;
263}
264
265/**
266 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_006
267 * @tc.name      : Create -> SetCallback -> Configure -> Prepare -> Start -> PushInputData -> SetCallback
268 * @tc.desc      : interface depend check
269 */
270HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_006, TestSize.Level2)
271{
272    OH_AVErrCode ret;
273    uint32_t trackId = -1;
274    uint8_t *data = nullptr;
275
276    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
277    OH_AVCodec *handle = Create(encoderDemo);
278    ASSERT_NE(nullptr, handle);
279
280    ret = SetCallback(encoderDemo, handle);
281    ASSERT_EQ(AV_ERR_OK, ret);
282
283    ret = Configure(encoderDemo, handle);
284    ASSERT_EQ(AV_ERR_OK, ret);
285
286    ret = Prepare(encoderDemo, handle);
287    ASSERT_EQ(AV_ERR_OK, ret);
288
289    ret = Start(encoderDemo, handle, trackId, data);
290    ASSERT_EQ(AV_ERR_OK, ret);
291
292    ret = PushInputData(encoderDemo, handle, trackId);
293    ASSERT_EQ(AV_ERR_OK, ret);
294
295    ret = SetCallback(encoderDemo, handle);
296    ASSERT_EQ(AV_ERR_OK, ret);
297
298    Destroy(encoderDemo, handle);
299    delete encoderDemo;
300}
301
302/**
303 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_007
304 * @tc.name      : Create -> SetCallback -> Configure -> Prepare -> Start -> PushInputData[EOS] -> SetCallback
305 * @tc.desc      : interface depend check
306 */
307HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_007, TestSize.Level2)
308{
309    OH_AVErrCode ret;
310    uint32_t trackId = -1;
311    uint8_t *data = nullptr;
312
313    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
314    OH_AVCodec *handle = Create(encoderDemo);
315    ASSERT_NE(nullptr, handle);
316
317    ret = SetCallback(encoderDemo, handle);
318    ASSERT_EQ(AV_ERR_OK, ret);
319
320    ret = Configure(encoderDemo, handle);
321    ASSERT_EQ(AV_ERR_OK, ret);
322
323    ret = Prepare(encoderDemo, handle);
324    ASSERT_EQ(AV_ERR_OK, ret);
325
326    ret = Start(encoderDemo, handle, trackId, data);
327    ASSERT_EQ(AV_ERR_OK, ret);
328
329    ret = PushInputDataEOS(encoderDemo, handle, trackId);
330    ASSERT_EQ(AV_ERR_OK, ret);
331
332    ret = SetCallback(encoderDemo, handle);
333    ASSERT_EQ(AV_ERR_OK, ret);
334
335    Destroy(encoderDemo, handle);
336    delete encoderDemo;
337}
338
339/**
340 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_008
341 * @tc.name      : Create -> SetCallback -> Configure -> Prepare -> Start -> Flush -> SetCallback
342 * @tc.desc      : interface depend check
343 */
344HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_008, TestSize.Level2)
345{
346    OH_AVErrCode ret;
347    uint32_t trackId = -1;
348    uint8_t *data = nullptr;
349
350    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
351    OH_AVCodec *handle = Create(encoderDemo);
352    ASSERT_NE(nullptr, handle);
353
354    ret = SetCallback(encoderDemo, handle);
355    ASSERT_EQ(AV_ERR_OK, ret);
356
357    ret = Configure(encoderDemo, handle);
358    ASSERT_EQ(AV_ERR_OK, ret);
359
360    ret = Prepare(encoderDemo, handle);
361    ASSERT_EQ(AV_ERR_OK, ret);
362
363    ret = Start(encoderDemo, handle, trackId, data);
364    ASSERT_EQ(AV_ERR_OK, ret);
365
366    ret = Flush(encoderDemo, handle);
367    ASSERT_EQ(AV_ERR_OK, ret);
368
369    ret = SetCallback(encoderDemo, handle);
370    ASSERT_EQ(AV_ERR_OK, ret);
371
372    Destroy(encoderDemo, handle);
373    delete encoderDemo;
374}
375
376/**
377 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_009
378 * @tc.name      : Create -> SetCallback -> Configure -> Prepare -> Start -> Stop -> SetCallback
379 * @tc.desc      : interface depend check
380 */
381HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_009, TestSize.Level2)
382{
383    OH_AVErrCode ret;
384    uint32_t trackId = -1;
385    uint8_t *data = nullptr;
386
387    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
388    OH_AVCodec *handle = Create(encoderDemo);
389    ASSERT_NE(nullptr, handle);
390
391    ret = SetCallback(encoderDemo, handle);
392    ASSERT_EQ(AV_ERR_OK, ret);
393
394    ret = Configure(encoderDemo, handle);
395    ASSERT_EQ(AV_ERR_OK, ret);
396
397    ret = Prepare(encoderDemo, handle);
398    ASSERT_EQ(AV_ERR_OK, ret);
399
400    ret = Start(encoderDemo, handle, trackId, data);
401    ASSERT_EQ(AV_ERR_OK, ret);
402
403    ret = Stop(encoderDemo, handle);
404    ASSERT_EQ(AV_ERR_OK, ret);
405
406    ret = SetCallback(encoderDemo, handle);
407    ASSERT_EQ(AV_ERR_OK, ret);
408
409    Destroy(encoderDemo, handle);
410    delete encoderDemo;
411}
412
413/**
414 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_010
415 * @tc.name      : Create -> SetCallback -> Configure -> Prepare -> Start -> Stop -> Reset -> SetCallback
416 * @tc.desc      : interface depend check
417 */
418HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_010, TestSize.Level2)
419{
420    OH_AVErrCode ret;
421    uint32_t trackId = -1;
422    uint8_t *data = nullptr;
423
424    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
425    OH_AVCodec *handle = Create(encoderDemo);
426    ASSERT_NE(nullptr, handle);
427    cout << "handle is " << handle << endl;
428
429    ret = SetCallback(encoderDemo, handle);
430    ASSERT_EQ(AV_ERR_OK, ret);
431    cout << "SetCallback ret is " << ret << endl;
432
433    ret = Configure(encoderDemo, handle);
434    ASSERT_EQ(AV_ERR_OK, ret);
435    cout << "Configure ret is " << ret << endl;
436
437    ret = Prepare(encoderDemo, handle);
438    ASSERT_EQ(AV_ERR_OK, ret);
439    cout << "Prepare ret is " << ret << endl;
440
441    ret = Start(encoderDemo, handle, trackId, data);
442    ASSERT_EQ(AV_ERR_OK, ret);
443    cout << "Start ret is " << ret << endl;
444
445    ret = Stop(encoderDemo, handle);
446    ASSERT_EQ(AV_ERR_OK, ret);
447    cout << "Stop ret is " << ret << endl;
448
449    ret = Reset(encoderDemo, handle);
450    ASSERT_EQ(AV_ERR_OK, ret);
451    cout << "Reset ret is " << ret << endl;
452
453    ret = SetCallback(encoderDemo, handle);
454    ASSERT_EQ(AV_ERR_OK, ret);
455    cout << "SetCallback ret is " << ret << endl;
456
457    Destroy(encoderDemo, handle);
458    delete encoderDemo;
459}
460
461/**
462 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_011
463 * @tc.name      : Create -> SetCallback -> Configure
464 * @tc.desc      : interface depend check
465 */
466HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_011, TestSize.Level2)
467{
468    OH_AVErrCode ret;
469
470    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
471    OH_AVCodec *handle = Create(encoderDemo);
472    ASSERT_NE(nullptr, handle);
473
474    ret = SetCallback(encoderDemo, handle);
475    ASSERT_EQ(AV_ERR_OK, ret);
476
477    ret = Configure(encoderDemo, handle);
478    ASSERT_EQ(AV_ERR_OK, ret);
479
480    Destroy(encoderDemo, handle);
481    delete encoderDemo;
482}
483
484/**
485 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_012
486 * @tc.name      : Create -> SetCallback -> Configure -> Configure
487 * @tc.desc      : interface depend check
488 */
489HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_012, TestSize.Level2)
490{
491    OH_AVErrCode ret;
492
493    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
494    OH_AVCodec *handle = Create(encoderDemo);
495    ASSERT_NE(nullptr, handle);
496
497    ret = SetCallback(encoderDemo, handle);
498    ASSERT_EQ(AV_ERR_OK, ret);
499
500    ret = Configure(encoderDemo, handle);
501    ASSERT_EQ(AV_ERR_OK, ret);
502
503    ret = Configure(encoderDemo, handle);
504    ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
505
506    Destroy(encoderDemo, handle);
507    delete encoderDemo;
508}
509
510/**
511 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_013
512 * @tc.name      : Create -> SetCallback -> Configure -> Prepare -> Configure
513 * @tc.desc      : interface depend check
514 */
515HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_013, TestSize.Level2)
516{
517    OH_AVErrCode ret;
518
519    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
520    OH_AVCodec *handle = Create(encoderDemo);
521    ASSERT_NE(nullptr, handle);
522
523    ret = SetCallback(encoderDemo, handle);
524    ASSERT_EQ(AV_ERR_OK, ret);
525
526    ret = Configure(encoderDemo, handle);
527    ASSERT_EQ(AV_ERR_OK, ret);
528
529    ret = Prepare(encoderDemo, handle);
530    ASSERT_EQ(AV_ERR_OK, ret);
531
532    ret = Configure(encoderDemo, handle);
533    ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
534
535    Destroy(encoderDemo, handle);
536    delete encoderDemo;
537}
538
539/**
540 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_014
541 * @tc.name      : Create -> SetCallback -> Configure -> Prepare -> Start -> Configure
542 * @tc.desc      : interface depend check
543 */
544HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_014, TestSize.Level2)
545{
546    OH_AVErrCode ret;
547    uint32_t trackId = -1;
548    uint8_t *data = nullptr;
549
550    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
551    OH_AVCodec *handle = Create(encoderDemo);
552    ASSERT_NE(nullptr, handle);
553
554    ret = SetCallback(encoderDemo, handle);
555    ASSERT_EQ(AV_ERR_OK, ret);
556
557    ret = Configure(encoderDemo, handle);
558    ASSERT_EQ(AV_ERR_OK, ret);
559
560    ret = Prepare(encoderDemo, handle);
561    ASSERT_EQ(AV_ERR_OK, ret);
562
563    ret = Start(encoderDemo, handle, trackId, data);
564    ASSERT_EQ(AV_ERR_OK, ret);
565
566    ret = Configure(encoderDemo, handle);
567    ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
568
569    Destroy(encoderDemo, handle);
570    delete encoderDemo;
571}
572
573/**
574 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_015
575 * @tc.name      : Create -> SetCallback -> Configure -> Prepare -> Start -> PushInputData -> Configure
576 * @tc.desc      : interface depend check
577 */
578HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_015, TestSize.Level2)
579{
580    OH_AVErrCode ret;
581    uint32_t trackId = -1;
582    uint8_t *data = nullptr;
583
584    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
585    OH_AVCodec *handle = Create(encoderDemo);
586    ASSERT_NE(nullptr, handle);
587
588    ret = SetCallback(encoderDemo, handle);
589    ASSERT_EQ(AV_ERR_OK, ret);
590
591    ret = Configure(encoderDemo, handle);
592    ASSERT_EQ(AV_ERR_OK, ret);
593
594    ret = Prepare(encoderDemo, handle);
595    ASSERT_EQ(AV_ERR_OK, ret);
596
597    ret = Start(encoderDemo, handle, trackId, data);
598    ASSERT_EQ(AV_ERR_OK, ret);
599
600    ret = PushInputData(encoderDemo, handle, trackId);
601    ASSERT_EQ(AV_ERR_OK, ret);
602
603    ret = Configure(encoderDemo, handle);
604    ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
605
606    Destroy(encoderDemo, handle);
607    delete encoderDemo;
608}
609
610/**
611 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_016
612 * @tc.name      : Create -> SetCallback -> Configure -> Prepare -> Start -> PushInputData[EOS] -> Configure
613 * @tc.desc      : interface depend check
614 */
615HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_016, TestSize.Level2)
616{
617    OH_AVErrCode ret;
618    uint32_t trackId = -1;
619    uint8_t *data = nullptr;
620
621    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
622    OH_AVCodec *handle = Create(encoderDemo);
623    ASSERT_NE(nullptr, handle);
624
625    ret = SetCallback(encoderDemo, handle);
626    ASSERT_EQ(AV_ERR_OK, ret);
627
628    ret = Configure(encoderDemo, handle);
629    ASSERT_EQ(AV_ERR_OK, ret);
630
631    ret = Prepare(encoderDemo, handle);
632    ASSERT_EQ(AV_ERR_OK, ret);
633
634    ret = Start(encoderDemo, handle, trackId, data);
635    ASSERT_EQ(AV_ERR_OK, ret);
636
637    ret = PushInputDataEOS(encoderDemo, handle, trackId);
638    ASSERT_EQ(AV_ERR_OK, ret);
639
640    ret = Configure(encoderDemo, handle);
641    ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
642
643    Destroy(encoderDemo, handle);
644    delete encoderDemo;
645}
646
647/**
648 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_017
649 * @tc.name      : Create -> SetCallback -> Configure -> Prepare -> Start -> Flush -> Configure
650 * @tc.desc      : interface depend check
651 */
652HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_017, TestSize.Level2)
653{
654    OH_AVErrCode ret;
655    uint32_t trackId = -1;
656    uint8_t *data = nullptr;
657
658    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
659    OH_AVCodec *handle = Create(encoderDemo);
660    ASSERT_NE(nullptr, handle);
661
662    ret = SetCallback(encoderDemo, handle);
663    ASSERT_EQ(AV_ERR_OK, ret);
664
665    ret = Configure(encoderDemo, handle);
666    ASSERT_EQ(AV_ERR_OK, ret);
667
668    ret = Prepare(encoderDemo, handle);
669    ASSERT_EQ(AV_ERR_OK, ret);
670
671    ret = Start(encoderDemo, handle, trackId, data);
672    ASSERT_EQ(AV_ERR_OK, ret);
673
674    ret = Flush(encoderDemo, handle);
675    ASSERT_EQ(AV_ERR_OK, ret);
676
677    ret = Configure(encoderDemo, handle);
678    ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
679
680    Destroy(encoderDemo, handle);
681    delete encoderDemo;
682}
683
684/**
685 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_018
686 * @tc.name      : Create -> SetCallback -> Configure -> Prepare -> Start -> Stop -> Configure
687 * @tc.desc      : interface depend check
688 */
689HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_018, TestSize.Level2)
690{
691    OH_AVErrCode ret;
692    uint32_t trackId = -1;
693    uint8_t *data = nullptr;
694
695    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
696    OH_AVCodec *handle = Create(encoderDemo);
697    ASSERT_NE(nullptr, handle);
698
699    ret = SetCallback(encoderDemo, handle);
700    ASSERT_EQ(AV_ERR_OK, ret);
701
702    ret = Configure(encoderDemo, handle);
703    ASSERT_EQ(AV_ERR_OK, ret);
704
705    ret = Prepare(encoderDemo, handle);
706    ASSERT_EQ(AV_ERR_OK, ret);
707
708    ret = Start(encoderDemo, handle, trackId, data);
709    ASSERT_EQ(AV_ERR_OK, ret);
710
711    ret = Stop(encoderDemo, handle);
712    ASSERT_EQ(AV_ERR_OK, ret);
713
714    ret = Configure(encoderDemo, handle);
715    ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
716
717    Destroy(encoderDemo, handle);
718    delete encoderDemo;
719}
720
721/**
722 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_019
723 * @tc.name      : Create -> SetCallback -> Configure -> Prepare -> Start -> Stop -> Reset -> Configure
724 * @tc.desc      : interface depend check
725 */
726HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_019, TestSize.Level2)
727{
728    OH_AVErrCode ret;
729    uint32_t trackId = -1;
730    uint8_t *data = nullptr;
731
732    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
733    OH_AVCodec *handle = Create(encoderDemo);
734    ASSERT_NE(nullptr, handle);
735
736    ret = SetCallback(encoderDemo, handle);
737    ASSERT_EQ(AV_ERR_OK, ret);
738
739    ret = Configure(encoderDemo, handle);
740    ASSERT_EQ(AV_ERR_OK, ret);
741
742    ret = Prepare(encoderDemo, handle);
743    ASSERT_EQ(AV_ERR_OK, ret);
744
745    ret = Start(encoderDemo, handle, trackId, data);
746    ASSERT_EQ(AV_ERR_OK, ret);
747
748    ret = Stop(encoderDemo, handle);
749    ASSERT_EQ(AV_ERR_OK, ret);
750
751    ret = Reset(encoderDemo, handle);
752    ASSERT_EQ(AV_ERR_OK, ret);
753
754    ret = Configure(encoderDemo, handle);
755    ASSERT_EQ(AV_ERR_OK, ret);
756
757    Destroy(encoderDemo, handle);
758    delete encoderDemo;
759}
760
761/**
762 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_020
763 * @tc.name      : Create -> Start
764 * @tc.desc      : interface depend check
765 */
766HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_020, TestSize.Level2)
767{
768    OH_AVErrCode ret;
769    uint32_t trackId = -1;
770    uint8_t *data = nullptr;
771
772    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
773    OH_AVCodec *handle = Create(encoderDemo);
774    ASSERT_NE(nullptr, handle);
775
776    ret = Start(encoderDemo, handle, trackId, data);
777    ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
778
779    Destroy(encoderDemo, handle);
780    delete encoderDemo;
781}
782
783/**
784 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_021
785 * @tc.name      : Create -> SetCallback -> Configure -> Prepare -> Start
786 * @tc.desc      : interface depend check
787 */
788HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_021, TestSize.Level2)
789{
790    OH_AVErrCode ret;
791    uint32_t trackId = -1;
792    uint8_t *data = nullptr;
793
794    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
795    OH_AVCodec *handle = Create(encoderDemo);
796    ASSERT_NE(nullptr, handle);
797
798    ret = SetCallback(encoderDemo, handle);
799    ASSERT_EQ(AV_ERR_OK, ret);
800
801    ret = Configure(encoderDemo, handle);
802    ASSERT_EQ(AV_ERR_OK, ret);
803
804    ret = Prepare(encoderDemo, handle);
805    ASSERT_EQ(AV_ERR_OK, ret);
806
807    ret = Start(encoderDemo, handle, trackId, data);
808    ASSERT_EQ(AV_ERR_OK, ret);
809
810    Destroy(encoderDemo, handle);
811    delete encoderDemo;
812}
813
814/**
815 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_022
816 * @tc.name      : Create -> SetCallback -> Configure -> Prepare -> Start -> Start
817 * @tc.desc      : interface depend check
818 */
819HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_022, TestSize.Level2)
820{
821    OH_AVErrCode ret;
822    uint32_t trackId = -1;
823    uint8_t *data = nullptr;
824
825    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
826    OH_AVCodec *handle = Create(encoderDemo);
827    ASSERT_NE(nullptr, handle);
828
829    ret = SetCallback(encoderDemo, handle);
830    ASSERT_EQ(AV_ERR_OK, ret);
831
832    ret = Configure(encoderDemo, handle);
833    ASSERT_EQ(AV_ERR_OK, ret);
834
835    ret = Prepare(encoderDemo, handle);
836    ASSERT_EQ(AV_ERR_OK, ret);
837
838    ret = Start(encoderDemo, handle, trackId, data);
839    ASSERT_EQ(AV_ERR_OK, ret);
840
841    ret = Start(encoderDemo, handle, trackId, data);
842    ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
843
844    Destroy(encoderDemo, handle);
845    delete encoderDemo;
846}
847
848/**
849 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_023
850 * @tc.name      : Create -> SetCallback -> Configure -> Prepare -> Start -> PushInputData -> Start
851 * @tc.desc      : interface depend check
852 */
853HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_023, TestSize.Level2)
854{
855    OH_AVErrCode ret;
856    uint32_t trackId = -1;
857    uint8_t *data = nullptr;
858
859    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
860    OH_AVCodec *handle = Create(encoderDemo);
861    ASSERT_NE(nullptr, handle);
862
863    ret = SetCallback(encoderDemo, handle);
864    ASSERT_EQ(AV_ERR_OK, ret);
865
866    ret = Configure(encoderDemo, handle);
867    ASSERT_EQ(AV_ERR_OK, ret);
868
869    ret = Prepare(encoderDemo, handle);
870    ASSERT_EQ(AV_ERR_OK, ret);
871
872    ret = Start(encoderDemo, handle, trackId, data);
873    ASSERT_EQ(AV_ERR_OK, ret);
874
875    ret = PushInputData(encoderDemo, handle, trackId);
876    ASSERT_EQ(AV_ERR_OK, ret);
877
878    ret = Start(encoderDemo, handle, trackId, data);
879    ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
880
881    Destroy(encoderDemo, handle);
882    delete encoderDemo;
883}
884
885/**
886 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_024
887 * @tc.name      : Create -> SetCallback -> Configure -> Prepare -> Start -> PushInputData[EOS] -> Start
888 * @tc.desc      : interface depend check
889 */
890HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_024, TestSize.Level2)
891{
892    OH_AVErrCode ret;
893    uint32_t trackId = -1;
894    uint8_t *data = nullptr;
895
896    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
897    OH_AVCodec *handle = Create(encoderDemo);
898    ASSERT_NE(nullptr, handle);
899
900    ret = SetCallback(encoderDemo, handle);
901    ASSERT_EQ(AV_ERR_OK, ret);
902
903    ret = Configure(encoderDemo, handle);
904    ASSERT_EQ(AV_ERR_OK, ret);
905
906    ret = Prepare(encoderDemo, handle);
907    ASSERT_EQ(AV_ERR_OK, ret);
908
909    ret = Start(encoderDemo, handle, trackId, data);
910    ASSERT_EQ(AV_ERR_OK, ret);
911
912    ret = PushInputDataEOS(encoderDemo, handle, trackId);
913    ASSERT_EQ(AV_ERR_OK, ret);
914
915    ret = Start(encoderDemo, handle, trackId, data);
916    ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
917
918    Destroy(encoderDemo, handle);
919    delete encoderDemo;
920}
921
922/**
923 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_025
924 * @tc.name      : Create -> SetCallback -> Configure -> Prepare -> Start -> Flush -> Start
925 * @tc.desc      : interface depend check
926 */
927HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_025, TestSize.Level2)
928{
929    OH_AVErrCode ret;
930    uint32_t trackId = -1;
931    uint8_t *data = nullptr;
932
933    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
934    OH_AVCodec *handle = Create(encoderDemo);
935    ASSERT_NE(nullptr, handle);
936
937    ret = SetCallback(encoderDemo, handle);
938    ASSERT_EQ(AV_ERR_OK, ret);
939
940    ret = Configure(encoderDemo, handle);
941    ASSERT_EQ(AV_ERR_OK, ret);
942
943    ret = Prepare(encoderDemo, handle);
944    ASSERT_EQ(AV_ERR_OK, ret);
945
946    ret = Start(encoderDemo, handle, trackId, data);
947    ASSERT_EQ(AV_ERR_OK, ret);
948
949    ret = Flush(encoderDemo, handle);
950    ASSERT_EQ(AV_ERR_OK, ret);
951
952    ret = Start(encoderDemo, handle, trackId, data);
953    ASSERT_EQ(AV_ERR_OK, ret);
954
955    Destroy(encoderDemo, handle);
956    delete encoderDemo;
957}
958
959/**
960 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_026
961 * @tc.name      : Create -> SetCallback -> Configure -> Prepare -> Start -> Stop -> Start
962 * @tc.desc      : interface depend check
963 */
964HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_026, TestSize.Level2)
965{
966    OH_AVErrCode ret;
967    uint32_t trackId = -1;
968    uint8_t *data = nullptr;
969
970    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
971    OH_AVCodec *handle = Create(encoderDemo);
972    ASSERT_NE(nullptr, handle);
973
974    ret = SetCallback(encoderDemo, handle);
975    ASSERT_EQ(AV_ERR_OK, ret);
976
977    ret = Configure(encoderDemo, handle);
978    ASSERT_EQ(AV_ERR_OK, ret);
979
980    ret = Prepare(encoderDemo, handle);
981    ASSERT_EQ(AV_ERR_OK, ret);
982
983    ret = Start(encoderDemo, handle, trackId, data);
984    ASSERT_EQ(AV_ERR_OK, ret);
985
986    ret = Stop(encoderDemo, handle);
987    ASSERT_EQ(AV_ERR_OK, ret);
988
989    ret = Start(encoderDemo, handle, trackId, data);
990    ASSERT_EQ(AV_ERR_OK, ret);
991
992    Destroy(encoderDemo, handle);
993    delete encoderDemo;
994}
995
996/**
997 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_027
998 * @tc.name      : Create -> SetCallback -> Configure -> Prepare -> Start -> Stop -> Reset -> Start
999 * @tc.desc      : interface depend check
1000 */
1001HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_027, TestSize.Level2)
1002{
1003    OH_AVErrCode ret;
1004    uint32_t trackId = -1;
1005    uint8_t *data = nullptr;
1006
1007    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
1008    OH_AVCodec *handle = Create(encoderDemo);
1009    ASSERT_NE(nullptr, handle);
1010
1011    ret = SetCallback(encoderDemo, handle);
1012    ASSERT_EQ(AV_ERR_OK, ret);
1013
1014    ret = Configure(encoderDemo, handle);
1015    ASSERT_EQ(AV_ERR_OK, ret);
1016
1017    ret = Prepare(encoderDemo, handle);
1018    ASSERT_EQ(AV_ERR_OK, ret);
1019
1020    ret = Start(encoderDemo, handle, trackId, data);
1021    ASSERT_EQ(AV_ERR_OK, ret);
1022
1023    ret = Stop(encoderDemo, handle);
1024    ASSERT_EQ(AV_ERR_OK, ret);
1025
1026    ret = Reset(encoderDemo, handle);
1027    ASSERT_EQ(AV_ERR_OK, ret);
1028
1029    ret = Start(encoderDemo, handle, trackId, data);
1030    ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
1031
1032    Destroy(encoderDemo, handle);
1033    delete encoderDemo;
1034}
1035
1036/**
1037 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_028
1038 * @tc.name      : Create -> PushInputData
1039 * @tc.desc      : interface depend check
1040 */
1041HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_028, TestSize.Level2)
1042{
1043    OH_AVErrCode ret;
1044    uint32_t trackId = -1;
1045
1046    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
1047    OH_AVCodec *handle = Create(encoderDemo);
1048    ASSERT_NE(nullptr, handle);
1049
1050    ret = PushInputData(encoderDemo, handle, trackId);
1051    ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
1052
1053    Destroy(encoderDemo, handle);
1054    delete encoderDemo;
1055}
1056
1057/**
1058 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_029
1059 * @tc.name      : Create -> SetCallback -> Configure -> Prepare -> PushInputData
1060 * @tc.desc      : interface depend check
1061 */
1062HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_029, TestSize.Level2)
1063{
1064    OH_AVErrCode ret;
1065    uint32_t trackId = -1;
1066
1067    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
1068    OH_AVCodec *handle = Create(encoderDemo);
1069    ASSERT_NE(nullptr, handle);
1070
1071    ret = SetCallback(encoderDemo, handle);
1072    ASSERT_EQ(AV_ERR_OK, ret);
1073
1074    ret = Configure(encoderDemo, handle);
1075    ASSERT_EQ(AV_ERR_OK, ret);
1076
1077    ret = Prepare(encoderDemo, handle);
1078    ASSERT_EQ(AV_ERR_OK, ret);
1079
1080    ret = PushInputData(encoderDemo, handle, trackId);
1081    ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
1082
1083    Destroy(encoderDemo, handle);
1084    delete encoderDemo;
1085}
1086
1087/**
1088 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_030
1089 * @tc.name      : Create -> SetCallback -> Configure -> Prepare -> Start -> PushInputData
1090 * @tc.desc      : interface depend check
1091 */
1092HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_030, TestSize.Level2)
1093{
1094    OH_AVErrCode ret;
1095    uint32_t trackId = -1;
1096    uint8_t *data = nullptr;
1097
1098    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
1099    OH_AVCodec *handle = Create(encoderDemo);
1100    ASSERT_NE(nullptr, handle);
1101
1102    ret = SetCallback(encoderDemo, handle);
1103    ASSERT_EQ(AV_ERR_OK, ret);
1104
1105    ret = Configure(encoderDemo, handle);
1106    ASSERT_EQ(AV_ERR_OK, ret);
1107
1108    ret = Prepare(encoderDemo, handle);
1109    ASSERT_EQ(AV_ERR_OK, ret);
1110
1111    ret = Start(encoderDemo, handle, trackId, data);
1112    ASSERT_EQ(AV_ERR_OK, ret);
1113
1114    cout << "index is " << trackId << endl;
1115    printf("data is %p\n", data);
1116    ret = PushInputData(encoderDemo, handle, trackId);
1117    ASSERT_EQ(AV_ERR_OK, ret);
1118
1119    Destroy(encoderDemo, handle);
1120    delete encoderDemo;
1121}
1122
1123/**
1124 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_031
1125 * @tc.name      : Create -> SetCallback -> Configure -> Prepare -> Start -> PushInputData -> PushInputData
1126 * @tc.desc      : interface depend check
1127 */
1128HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_031, TestSize.Level2)
1129{
1130    OH_AVErrCode ret;
1131    uint32_t trackId = -1;
1132    uint8_t *data = nullptr;
1133
1134    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
1135    OH_AVCodec *handle = Create(encoderDemo);
1136    ASSERT_NE(nullptr, handle);
1137
1138    ret = SetCallback(encoderDemo, handle);
1139    ASSERT_EQ(AV_ERR_OK, ret);
1140
1141    ret = Configure(encoderDemo, handle);
1142    ASSERT_EQ(AV_ERR_OK, ret);
1143
1144    ret = Prepare(encoderDemo, handle);
1145    ASSERT_EQ(AV_ERR_OK, ret);
1146
1147    ret = Start(encoderDemo, handle, trackId, data);
1148    ASSERT_EQ(AV_ERR_OK, ret);
1149
1150    ret = PushInputData(encoderDemo, handle, trackId);
1151    ASSERT_EQ(AV_ERR_OK, ret);
1152
1153    ret = PushInputData(encoderDemo, handle, trackId);
1154    ASSERT_EQ(AV_ERR_UNKNOWN, ret);
1155
1156    Destroy(encoderDemo, handle);
1157    delete encoderDemo;
1158}
1159
1160/**
1161 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_032
1162 * @tc.name      : Create -> SetCallback -> Configure -> Prepare -> Start -> PushInputData[EOS] -> PushInputData
1163 * @tc.desc      : interface depend check
1164 */
1165HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_032, TestSize.Level2)
1166{
1167    OH_AVErrCode ret;
1168    uint32_t trackId = -1;
1169    uint8_t *data = nullptr;
1170
1171    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
1172    OH_AVCodec *handle = Create(encoderDemo);
1173    ASSERT_NE(nullptr, handle);
1174
1175    ret = SetCallback(encoderDemo, handle);
1176    ASSERT_EQ(AV_ERR_OK, ret);
1177
1178    ret = Configure(encoderDemo, handle);
1179    ASSERT_EQ(AV_ERR_OK, ret);
1180
1181    ret = Prepare(encoderDemo, handle);
1182    ASSERT_EQ(AV_ERR_OK, ret);
1183
1184    ret = Start(encoderDemo, handle, trackId, data);
1185    ASSERT_EQ(AV_ERR_OK, ret);
1186
1187    ret = PushInputDataEOS(encoderDemo, handle, trackId);
1188    ASSERT_EQ(AV_ERR_OK, ret);
1189
1190    ret = PushInputData(encoderDemo, handle, trackId);
1191    ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
1192
1193    Destroy(encoderDemo, handle);
1194    delete encoderDemo;
1195}
1196
1197/**
1198 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_033
1199 * @tc.name      : Create -> SetCallback -> Configure -> Prepare -> Start -> Flush -> PushInputData
1200 * @tc.desc      : interface depend check
1201 */
1202HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_033, TestSize.Level2)
1203{
1204    OH_AVErrCode ret;
1205    uint32_t trackId = -1;
1206    uint8_t *data = nullptr;
1207
1208    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
1209    OH_AVCodec *handle = Create(encoderDemo);
1210    ASSERT_NE(nullptr, handle);
1211
1212    ret = SetCallback(encoderDemo, handle);
1213    ASSERT_EQ(AV_ERR_OK, ret);
1214
1215    ret = Configure(encoderDemo, handle);
1216    ASSERT_EQ(AV_ERR_OK, ret);
1217
1218    ret = Prepare(encoderDemo, handle);
1219    ASSERT_EQ(AV_ERR_OK, ret);
1220
1221    ret = Start(encoderDemo, handle, trackId, data);
1222    ASSERT_EQ(AV_ERR_OK, ret);
1223
1224    ret = Flush(encoderDemo, handle);
1225    ASSERT_EQ(AV_ERR_OK, ret);
1226
1227    ret = PushInputData(encoderDemo, handle, trackId);
1228    ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
1229
1230    Destroy(encoderDemo, handle);
1231    delete encoderDemo;
1232}
1233
1234/**
1235 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_034
1236 * @tc.name      : Create -> SetCallback -> Configure -> Prepare -> Start -> Flush -> Start -> PushInputData
1237 * @tc.desc      : interface depend check
1238 */
1239HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_034, TestSize.Level2)
1240{
1241    OH_AVErrCode ret;
1242    uint32_t trackId = -1;
1243    uint8_t *data = nullptr;
1244
1245    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
1246    OH_AVCodec *handle = Create(encoderDemo);
1247    ASSERT_NE(nullptr, handle);
1248
1249    ret = SetCallback(encoderDemo, handle);
1250    ASSERT_EQ(AV_ERR_OK, ret);
1251
1252    ret = Configure(encoderDemo, handle);
1253    ASSERT_EQ(AV_ERR_OK, ret);
1254
1255    ret = Prepare(encoderDemo, handle);
1256    ASSERT_EQ(AV_ERR_OK, ret);
1257
1258    ret = Start(encoderDemo, handle, trackId, data);
1259    ASSERT_EQ(AV_ERR_OK, ret);
1260
1261    ret = Flush(encoderDemo, handle);
1262    ASSERT_EQ(AV_ERR_OK, ret);
1263
1264    ret = Start(encoderDemo, handle, trackId, data);
1265    ASSERT_EQ(AV_ERR_OK, ret);
1266
1267    ret = PushInputData(encoderDemo, handle, trackId);
1268    ASSERT_EQ(AV_ERR_OK, ret);
1269
1270    Destroy(encoderDemo, handle);
1271    delete encoderDemo;
1272}
1273
1274/**
1275 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_035
1276 * @tc.name      : Create -> SetCallback -> Configure -> Prepare -> Start -> Stop -> PushInputData
1277 * @tc.desc      : interface depend check
1278 */
1279HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_035, TestSize.Level2)
1280{
1281    OH_AVErrCode ret;
1282    uint32_t trackId = -1;
1283    uint8_t *data = nullptr;
1284
1285    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
1286    OH_AVCodec *handle = Create(encoderDemo);
1287    ASSERT_NE(nullptr, handle);
1288
1289    ret = SetCallback(encoderDemo, handle);
1290    ASSERT_EQ(AV_ERR_OK, ret);
1291
1292    ret = Configure(encoderDemo, handle);
1293    ASSERT_EQ(AV_ERR_OK, ret);
1294
1295    ret = Prepare(encoderDemo, handle);
1296    ASSERT_EQ(AV_ERR_OK, ret);
1297
1298    ret = Start(encoderDemo, handle, trackId, data);
1299    ASSERT_EQ(AV_ERR_OK, ret);
1300
1301    ret = Stop(encoderDemo, handle);
1302    ASSERT_EQ(AV_ERR_OK, ret);
1303
1304    ret = PushInputData(encoderDemo, handle, trackId);
1305    ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
1306
1307    Destroy(encoderDemo, handle);
1308    delete encoderDemo;
1309}
1310
1311/**
1312 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_036
1313 * @tc.name      : Create -> SetCallback -> Configure -> Prepare -> Start -> Stop -> Reset -> PushInputData
1314 * @tc.desc      : interface depend check
1315 */
1316HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_036, TestSize.Level2)
1317{
1318    OH_AVErrCode ret;
1319    uint32_t trackId = -1;
1320    uint8_t *data = nullptr;
1321
1322    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
1323    OH_AVCodec *handle = Create(encoderDemo);
1324    ASSERT_NE(nullptr, handle);
1325
1326    ret = SetCallback(encoderDemo, handle);
1327    ASSERT_EQ(AV_ERR_OK, ret);
1328
1329    ret = Configure(encoderDemo, handle);
1330    ASSERT_EQ(AV_ERR_OK, ret);
1331
1332    ret = Prepare(encoderDemo, handle);
1333    ASSERT_EQ(AV_ERR_OK, ret);
1334
1335    ret = Start(encoderDemo, handle, trackId, data);
1336    ASSERT_EQ(AV_ERR_OK, ret);
1337
1338    ret = Stop(encoderDemo, handle);
1339    ASSERT_EQ(AV_ERR_OK, ret);
1340
1341    ret = Reset(encoderDemo, handle);
1342    ASSERT_EQ(AV_ERR_OK, ret);
1343
1344    ret = PushInputData(encoderDemo, handle, trackId);
1345    ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
1346
1347    Destroy(encoderDemo, handle);
1348    delete encoderDemo;
1349}
1350
1351/**
1352 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_037
1353 * @tc.name      : Create -> Flush
1354 * @tc.desc      : interface depend check
1355 */
1356HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_037, TestSize.Level2)
1357{
1358    OH_AVErrCode ret;
1359
1360    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
1361    OH_AVCodec *handle = Create(encoderDemo);
1362    ASSERT_NE(nullptr, handle);
1363
1364    ret = Flush(encoderDemo, handle);
1365    ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
1366
1367    Destroy(encoderDemo, handle);
1368    delete encoderDemo;
1369}
1370
1371/**
1372 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_038
1373 * @tc.name      : Create -> SetCallback -> Configure -> Prepare -> Flush
1374 * @tc.desc      : interface depend check
1375 */
1376HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_038, TestSize.Level2)
1377{
1378    OH_AVErrCode ret;
1379
1380    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
1381    OH_AVCodec *handle = Create(encoderDemo);
1382    ASSERT_NE(nullptr, handle);
1383
1384    ret = SetCallback(encoderDemo, handle);
1385    ASSERT_EQ(AV_ERR_OK, ret);
1386
1387    ret = Configure(encoderDemo, handle);
1388    ASSERT_EQ(AV_ERR_OK, ret);
1389
1390    ret = Prepare(encoderDemo, handle);
1391    ASSERT_EQ(AV_ERR_OK, ret);
1392
1393    ret = Flush(encoderDemo, handle);
1394    ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
1395
1396    Destroy(encoderDemo, handle);
1397    delete encoderDemo;
1398}
1399
1400/**
1401 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_039
1402 * @tc.name      : Create -> SetCallback -> Configure -> Prepare -> Start -> Flush
1403 * @tc.desc      : interface depend check
1404 */
1405HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_039, TestSize.Level2)
1406{
1407    OH_AVErrCode ret;
1408    uint32_t trackId = -1;
1409    uint8_t *data = nullptr;
1410
1411    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
1412    OH_AVCodec *handle = Create(encoderDemo);
1413    ASSERT_NE(nullptr, handle);
1414
1415    ret = SetCallback(encoderDemo, handle);
1416    ASSERT_EQ(AV_ERR_OK, ret);
1417
1418    ret = Configure(encoderDemo, handle);
1419    ASSERT_EQ(AV_ERR_OK, ret);
1420
1421    ret = Prepare(encoderDemo, handle);
1422    ASSERT_EQ(AV_ERR_OK, ret);
1423
1424    ret = Start(encoderDemo, handle, trackId, data);
1425    ASSERT_EQ(AV_ERR_OK, ret);
1426
1427    ret = Flush(encoderDemo, handle);
1428    ASSERT_EQ(AV_ERR_OK, ret);
1429
1430    Destroy(encoderDemo, handle);
1431    delete encoderDemo;
1432}
1433
1434/**
1435 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_040
1436 * @tc.name      : Create -> SetCallback -> Configure -> Prepare -> Start -> PushInputData -> Flush
1437 * @tc.desc      : interface depend check
1438 */
1439HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_040, TestSize.Level2)
1440{
1441    OH_AVErrCode ret;
1442    uint32_t trackId = -1;
1443    uint8_t *data = nullptr;
1444
1445    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
1446    OH_AVCodec *handle = Create(encoderDemo);
1447    ASSERT_NE(nullptr, handle);
1448
1449    ret = SetCallback(encoderDemo, handle);
1450    ASSERT_EQ(AV_ERR_OK, ret);
1451
1452    ret = Configure(encoderDemo, handle);
1453    ASSERT_EQ(AV_ERR_OK, ret);
1454
1455    ret = Prepare(encoderDemo, handle);
1456    ASSERT_EQ(AV_ERR_OK, ret);
1457
1458    ret = Start(encoderDemo, handle, trackId, data);
1459    ASSERT_EQ(AV_ERR_OK, ret);
1460
1461    ret = PushInputData(encoderDemo, handle, trackId);
1462    ASSERT_EQ(AV_ERR_OK, ret);
1463
1464    ret = Flush(encoderDemo, handle);
1465    ASSERT_EQ(AV_ERR_OK, ret);
1466
1467    Destroy(encoderDemo, handle);
1468    delete encoderDemo;
1469}
1470
1471/**
1472 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_041
1473 * @tc.name      : Create -> SetCallback -> Configure -> Prepare -> Start -> PushInputData[EOS] -> Flush
1474 * @tc.desc      : interface depend check
1475 */
1476HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_041, TestSize.Level2)
1477{
1478    OH_AVErrCode ret;
1479    uint32_t trackId = -1;
1480    uint8_t *data = nullptr;
1481
1482    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
1483    OH_AVCodec *handle = Create(encoderDemo);
1484    ASSERT_NE(nullptr, handle);
1485
1486    ret = SetCallback(encoderDemo, handle);
1487    ASSERT_EQ(AV_ERR_OK, ret);
1488
1489    ret = Configure(encoderDemo, handle);
1490    ASSERT_EQ(AV_ERR_OK, ret);
1491
1492    ret = Prepare(encoderDemo, handle);
1493    ASSERT_EQ(AV_ERR_OK, ret);
1494
1495    ret = Start(encoderDemo, handle, trackId, data);
1496    ASSERT_EQ(AV_ERR_OK, ret);
1497
1498    ret = PushInputDataEOS(encoderDemo, handle, trackId);
1499    ASSERT_EQ(AV_ERR_OK, ret);
1500
1501    ret = Flush(encoderDemo, handle);
1502    ASSERT_EQ(AV_ERR_OK, ret);
1503
1504    Destroy(encoderDemo, handle);
1505    delete encoderDemo;
1506}
1507
1508/**
1509 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_042
1510 * @tc.name      : Create -> SetCallback -> Configure -> Prepare -> Start -> Flush -> Flush
1511 * @tc.desc      : interface depend check
1512 */
1513HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_042, TestSize.Level2)
1514{
1515    OH_AVErrCode ret;
1516    uint32_t trackId = -1;
1517    uint8_t *data = nullptr;
1518
1519    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
1520    OH_AVCodec *handle = Create(encoderDemo);
1521    ASSERT_NE(nullptr, handle);
1522
1523    ret = SetCallback(encoderDemo, handle);
1524    ASSERT_EQ(AV_ERR_OK, ret);
1525
1526    ret = Configure(encoderDemo, handle);
1527    ASSERT_EQ(AV_ERR_OK, ret);
1528
1529    ret = Prepare(encoderDemo, handle);
1530    ASSERT_EQ(AV_ERR_OK, ret);
1531
1532    ret = Start(encoderDemo, handle, trackId, data);
1533    ASSERT_EQ(AV_ERR_OK, ret);
1534
1535    ret = Flush(encoderDemo, handle);
1536    ASSERT_EQ(AV_ERR_OK, ret);
1537
1538    ret = Flush(encoderDemo, handle);
1539    ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
1540
1541    Destroy(encoderDemo, handle);
1542    delete encoderDemo;
1543}
1544
1545/**
1546 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_043
1547 * @tc.name      : Create -> SetCallback -> Configure -> Prepare -> Start -> Stop -> Flush
1548 * @tc.desc      : interface depend check
1549 */
1550HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_043, TestSize.Level2)
1551{
1552    OH_AVErrCode ret;
1553    uint32_t trackId = -1;
1554    uint8_t *data = nullptr;
1555
1556    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
1557    OH_AVCodec *handle = Create(encoderDemo);
1558    ASSERT_NE(nullptr, handle);
1559
1560    ret = SetCallback(encoderDemo, handle);
1561    ASSERT_EQ(AV_ERR_OK, ret);
1562
1563    ret = Configure(encoderDemo, handle);
1564    ASSERT_EQ(AV_ERR_OK, ret);
1565
1566    ret = Prepare(encoderDemo, handle);
1567    ASSERT_EQ(AV_ERR_OK, ret);
1568
1569    ret = Start(encoderDemo, handle, trackId, data);
1570    ASSERT_EQ(AV_ERR_OK, ret);
1571
1572    ret = Stop(encoderDemo, handle);
1573    ASSERT_EQ(AV_ERR_OK, ret);
1574
1575    ret = Flush(encoderDemo, handle);
1576    ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
1577
1578    Destroy(encoderDemo, handle);
1579    delete encoderDemo;
1580}
1581
1582/**
1583 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_044
1584 * @tc.name      : Create -> SetCallback -> Configure -> Prepare -> Start -> Stop -> Reset -> Flush
1585 * @tc.desc      : interface depend check
1586 */
1587HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_044, TestSize.Level2)
1588{
1589    OH_AVErrCode ret;
1590    uint32_t trackId = -1;
1591    uint8_t *data = nullptr;
1592
1593    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
1594    OH_AVCodec *handle = Create(encoderDemo);
1595    ASSERT_NE(nullptr, handle);
1596
1597    ret = SetCallback(encoderDemo, handle);
1598    ASSERT_EQ(AV_ERR_OK, ret);
1599
1600    ret = Configure(encoderDemo, handle);
1601    ASSERT_EQ(AV_ERR_OK, ret);
1602
1603    ret = Prepare(encoderDemo, handle);
1604    ASSERT_EQ(AV_ERR_OK, ret);
1605
1606    ret = Start(encoderDemo, handle, trackId, data);
1607    ASSERT_EQ(AV_ERR_OK, ret);
1608
1609    ret = Stop(encoderDemo, handle);
1610    ASSERT_EQ(AV_ERR_OK, ret);
1611
1612    ret = Reset(encoderDemo, handle);
1613    ASSERT_EQ(AV_ERR_OK, ret);
1614
1615    ret = Flush(encoderDemo, handle);
1616    ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
1617
1618    Destroy(encoderDemo, handle);
1619    delete encoderDemo;
1620}
1621
1622/**
1623 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_045
1624 * @tc.name      : Create -> Stop
1625 * @tc.desc      : interface depend check
1626 */
1627HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_045, TestSize.Level2)
1628{
1629    OH_AVErrCode ret;
1630
1631    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
1632    OH_AVCodec *handle = Create(encoderDemo);
1633    ASSERT_NE(nullptr, handle);
1634
1635    ret = Stop(encoderDemo, handle);
1636    ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
1637
1638    Destroy(encoderDemo, handle);
1639    delete encoderDemo;
1640}
1641
1642/**
1643 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_046
1644 * @tc.name      : Create -> SetCallback -> Configure -> Prepare -> Stop
1645 * @tc.desc      : interface depend check
1646 */
1647HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_046, TestSize.Level2)
1648{
1649    OH_AVErrCode ret;
1650
1651    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
1652    OH_AVCodec *handle = Create(encoderDemo);
1653    ASSERT_NE(nullptr, handle);
1654
1655    ret = SetCallback(encoderDemo, handle);
1656    ASSERT_EQ(AV_ERR_OK, ret);
1657
1658    ret = Configure(encoderDemo, handle);
1659    ASSERT_EQ(AV_ERR_OK, ret);
1660
1661    ret = Prepare(encoderDemo, handle);
1662    ASSERT_EQ(AV_ERR_OK, ret);
1663
1664    ret = Stop(encoderDemo, handle);
1665    ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
1666
1667    Destroy(encoderDemo, handle);
1668    delete encoderDemo;
1669}
1670
1671/**
1672 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_047
1673 * @tc.name      : Create -> SetCallback -> Configure -> Prepare -> Start -> Stop
1674 * @tc.desc      : interface depend check
1675 */
1676HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_047, TestSize.Level2)
1677{
1678    OH_AVErrCode ret;
1679    uint32_t trackId = -1;
1680    uint8_t *data = nullptr;
1681
1682    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
1683    OH_AVCodec *handle = Create(encoderDemo);
1684    ASSERT_NE(nullptr, handle);
1685
1686    ret = SetCallback(encoderDemo, handle);
1687    ASSERT_EQ(AV_ERR_OK, ret);
1688
1689    ret = Configure(encoderDemo, handle);
1690    ASSERT_EQ(AV_ERR_OK, ret);
1691
1692    ret = Prepare(encoderDemo, handle);
1693    ASSERT_EQ(AV_ERR_OK, ret);
1694
1695    ret = Start(encoderDemo, handle, trackId, data);
1696    ASSERT_EQ(AV_ERR_OK, ret);
1697
1698    ret = Stop(encoderDemo, handle);
1699    ASSERT_EQ(AV_ERR_OK, ret);
1700
1701    Destroy(encoderDemo, handle);
1702    delete encoderDemo;
1703}
1704
1705/**
1706 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_048
1707 * @tc.name      : Create -> SetCallback -> Configure -> Prepare -> Start -> PushInputData -> Stop
1708 * @tc.desc      : interface depend check
1709 */
1710HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_048, TestSize.Level2)
1711{
1712    OH_AVErrCode ret;
1713    uint32_t trackId = -1;
1714    uint8_t *data = nullptr;
1715
1716    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
1717    OH_AVCodec *handle = Create(encoderDemo);
1718    ASSERT_NE(nullptr, handle);
1719
1720    ret = SetCallback(encoderDemo, handle);
1721    ASSERT_EQ(AV_ERR_OK, ret);
1722
1723    ret = Configure(encoderDemo, handle);
1724    ASSERT_EQ(AV_ERR_OK, ret);
1725
1726    ret = Prepare(encoderDemo, handle);
1727    ASSERT_EQ(AV_ERR_OK, ret);
1728
1729    ret = Start(encoderDemo, handle, trackId, data);
1730    ASSERT_EQ(AV_ERR_OK, ret);
1731
1732    ret = PushInputData(encoderDemo, handle, trackId);
1733    ASSERT_EQ(AV_ERR_OK, ret);
1734
1735    ret = Stop(encoderDemo, handle);
1736    ASSERT_EQ(AV_ERR_OK, ret);
1737
1738    Destroy(encoderDemo, handle);
1739    delete encoderDemo;
1740}
1741
1742/**
1743 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_049
1744 * @tc.name      : Create -> SetCallback -> Configure -> Prepare -> Start -> PushInputData[EOS] -> Stop
1745 * @tc.desc      : interface depend check
1746 */
1747HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_049, TestSize.Level2)
1748{
1749    OH_AVErrCode ret;
1750    uint32_t trackId = -1;
1751    uint8_t *data = nullptr;
1752
1753    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
1754    OH_AVCodec *handle = Create(encoderDemo);
1755    ASSERT_NE(nullptr, handle);
1756
1757    ret = SetCallback(encoderDemo, handle);
1758    ASSERT_EQ(AV_ERR_OK, ret);
1759
1760    ret = Configure(encoderDemo, handle);
1761    ASSERT_EQ(AV_ERR_OK, ret);
1762
1763    ret = Prepare(encoderDemo, handle);
1764    ASSERT_EQ(AV_ERR_OK, ret);
1765
1766    ret = Start(encoderDemo, handle, trackId, data);
1767    ASSERT_EQ(AV_ERR_OK, ret);
1768
1769    ret = PushInputDataEOS(encoderDemo, handle, trackId);
1770    ASSERT_EQ(AV_ERR_OK, ret);
1771
1772    ret = Stop(encoderDemo, handle);
1773    ASSERT_EQ(AV_ERR_OK, ret);
1774
1775    Destroy(encoderDemo, handle);
1776    delete encoderDemo;
1777}
1778
1779/**
1780 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_050
1781 * @tc.name      : Create -> SetCallback -> Configure -> Prepare -> Start -> Flush -> Stop
1782 * @tc.desc      : interface depend check
1783 */
1784HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_050, TestSize.Level2)
1785{
1786    OH_AVErrCode ret;
1787    uint32_t trackId = -1;
1788    uint8_t *data = nullptr;
1789
1790    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
1791    OH_AVCodec *handle = Create(encoderDemo);
1792    ASSERT_NE(nullptr, handle);
1793
1794    ret = SetCallback(encoderDemo, handle);
1795    ASSERT_EQ(AV_ERR_OK, ret);
1796
1797    ret = Configure(encoderDemo, handle);
1798    ASSERT_EQ(AV_ERR_OK, ret);
1799
1800    ret = Prepare(encoderDemo, handle);
1801    ASSERT_EQ(AV_ERR_OK, ret);
1802
1803    ret = Start(encoderDemo, handle, trackId, data);
1804    ASSERT_EQ(AV_ERR_OK, ret);
1805
1806    ret = Flush(encoderDemo, handle);
1807    ASSERT_EQ(AV_ERR_OK, ret);
1808
1809    ret = Stop(encoderDemo, handle);
1810    ASSERT_EQ(AV_ERR_OK, ret);
1811
1812    Destroy(encoderDemo, handle);
1813    delete encoderDemo;
1814}
1815
1816/**
1817 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_051
1818 * @tc.name      : Create -> SetCallback -> Configure -> Prepare -> Start -> Stop -> Stop
1819 * @tc.desc      : interface depend check
1820 */
1821HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_051, TestSize.Level2)
1822{
1823    OH_AVErrCode ret;
1824    uint32_t trackId = -1;
1825    uint8_t *data = nullptr;
1826
1827    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
1828    OH_AVCodec *handle = Create(encoderDemo);
1829    ASSERT_NE(nullptr, handle);
1830
1831    ret = SetCallback(encoderDemo, handle);
1832    ASSERT_EQ(AV_ERR_OK, ret);
1833
1834    ret = Configure(encoderDemo, handle);
1835    ASSERT_EQ(AV_ERR_OK, ret);
1836
1837    ret = Prepare(encoderDemo, handle);
1838    ASSERT_EQ(AV_ERR_OK, ret);
1839
1840    ret = Start(encoderDemo, handle, trackId, data);
1841    ASSERT_EQ(AV_ERR_OK, ret);
1842
1843    ret = Stop(encoderDemo, handle);
1844    ASSERT_EQ(AV_ERR_OK, ret);
1845
1846    ret = Stop(encoderDemo, handle);
1847    ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
1848
1849    Destroy(encoderDemo, handle);
1850    delete encoderDemo;
1851}
1852
1853/**
1854 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_052
1855 * @tc.name      : Create -> SetCallback -> Configure -> Prepare -> Start -> Stop -> Reset -> Stop
1856 * @tc.desc      : interface depend check
1857 */
1858HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_052, TestSize.Level2)
1859{
1860    OH_AVErrCode ret;
1861    uint32_t trackId = -1;
1862    uint8_t *data = nullptr;
1863
1864    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
1865    OH_AVCodec *handle = Create(encoderDemo);
1866    ASSERT_NE(nullptr, handle);
1867
1868    ret = SetCallback(encoderDemo, handle);
1869    ASSERT_EQ(AV_ERR_OK, ret);
1870
1871    ret = Configure(encoderDemo, handle);
1872    ASSERT_EQ(AV_ERR_OK, ret);
1873
1874    ret = Prepare(encoderDemo, handle);
1875    ASSERT_EQ(AV_ERR_OK, ret);
1876
1877    ret = Start(encoderDemo, handle, trackId, data);
1878    ASSERT_EQ(AV_ERR_OK, ret);
1879
1880    ret = Stop(encoderDemo, handle);
1881    ASSERT_EQ(AV_ERR_OK, ret);
1882
1883    ret = Reset(encoderDemo, handle);
1884    ASSERT_EQ(AV_ERR_OK, ret);
1885
1886    ret = Stop(encoderDemo, handle);
1887    ASSERT_EQ(AV_ERR_INVALID_STATE, ret);
1888
1889    Destroy(encoderDemo, handle);
1890    delete encoderDemo;
1891}
1892
1893/**
1894 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_053
1895 * @tc.name      : Creat -> Reset
1896 * @tc.desc      : interface depend check
1897 */
1898HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_053, TestSize.Level2)
1899{
1900    OH_AVErrCode ret;
1901
1902    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
1903    OH_AVCodec *handle = Create(encoderDemo);
1904    ASSERT_NE(nullptr, handle);
1905
1906    ret = Reset(encoderDemo, handle);
1907    ASSERT_EQ(AV_ERR_OK, ret);
1908
1909    Destroy(encoderDemo, handle);
1910    delete encoderDemo;
1911}
1912
1913/**
1914 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_054
1915 * @tc.name      : Creat -> SetCallback -> Configure -> Prepare -> Reset
1916 * @tc.desc      : interface depend check
1917 */
1918HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_054, TestSize.Level2)
1919{
1920    OH_AVErrCode ret;
1921
1922    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
1923    OH_AVCodec *handle = Create(encoderDemo);
1924    ASSERT_NE(nullptr, handle);
1925
1926    ret = SetCallback(encoderDemo, handle);
1927    ASSERT_EQ(AV_ERR_OK, ret);
1928
1929    ret = Configure(encoderDemo, handle);
1930    ASSERT_EQ(AV_ERR_OK, ret);
1931
1932    ret = Prepare(encoderDemo, handle);
1933    ASSERT_EQ(AV_ERR_OK, ret);
1934
1935    ret = Reset(encoderDemo, handle);
1936    ASSERT_EQ(AV_ERR_OK, ret);
1937
1938    Destroy(encoderDemo, handle);
1939    delete encoderDemo;
1940}
1941
1942/**
1943 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_055
1944 * @tc.name      : Creat -> SetCallback -> Configure -> Prepare -> Start -> Reset
1945 * @tc.desc      : interface depend check
1946 */
1947HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_055, TestSize.Level2)
1948{
1949    OH_AVErrCode ret;
1950    uint32_t trackId = -1;
1951    uint8_t *data = nullptr;
1952
1953    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
1954    OH_AVCodec *handle = Create(encoderDemo);
1955    ASSERT_NE(nullptr, handle);
1956
1957    ret = SetCallback(encoderDemo, handle);
1958    ASSERT_EQ(AV_ERR_OK, ret);
1959
1960    ret = Configure(encoderDemo, handle);
1961    ASSERT_EQ(AV_ERR_OK, ret);
1962
1963    ret = Prepare(encoderDemo, handle);
1964    ASSERT_EQ(AV_ERR_OK, ret);
1965
1966    ret = Start(encoderDemo, handle, trackId, data);
1967    ASSERT_EQ(AV_ERR_OK, ret);
1968
1969    ret = Reset(encoderDemo, handle);
1970    ASSERT_EQ(AV_ERR_OK, ret);
1971
1972    Destroy(encoderDemo, handle);
1973    delete encoderDemo;
1974}
1975
1976/**
1977 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_056
1978 * @tc.name      : Creat -> SetCallback -> Configure -> Prepare -> Start -> PushInputData -> Reset
1979 * @tc.desc      : interface depend check
1980 */
1981HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_056, TestSize.Level2)
1982{
1983    OH_AVErrCode ret;
1984    uint32_t trackId = -1;
1985    uint8_t *data = nullptr;
1986
1987    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
1988    OH_AVCodec *handle = Create(encoderDemo);
1989    ASSERT_NE(nullptr, handle);
1990
1991    ret = SetCallback(encoderDemo, handle);
1992    ASSERT_EQ(AV_ERR_OK, ret);
1993
1994    ret = Configure(encoderDemo, handle);
1995    ASSERT_EQ(AV_ERR_OK, ret);
1996
1997    ret = Prepare(encoderDemo, handle);
1998    ASSERT_EQ(AV_ERR_OK, ret);
1999
2000    ret = Start(encoderDemo, handle, trackId, data);
2001    ASSERT_EQ(AV_ERR_OK, ret);
2002
2003    ret = PushInputData(encoderDemo, handle, trackId);
2004    ASSERT_EQ(AV_ERR_OK, ret);
2005
2006    ret = Reset(encoderDemo, handle);
2007    ASSERT_EQ(AV_ERR_OK, ret);
2008
2009    Destroy(encoderDemo, handle);
2010    delete encoderDemo;
2011}
2012
2013/**
2014 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_057
2015 * @tc.name      : Creat -> SetCallback -> Configure -> Prepare -> Start -> PushInputData[EOS] -> Reset
2016 * @tc.desc      : interface depend check
2017 */
2018HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_057, TestSize.Level2)
2019{
2020    OH_AVErrCode ret;
2021    uint32_t trackId = -1;
2022    uint8_t *data = nullptr;
2023
2024    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
2025    OH_AVCodec *handle = Create(encoderDemo);
2026    ASSERT_NE(nullptr, handle);
2027
2028    ret = SetCallback(encoderDemo, handle);
2029    ASSERT_EQ(AV_ERR_OK, ret);
2030
2031    ret = Configure(encoderDemo, handle);
2032    ASSERT_EQ(AV_ERR_OK, ret);
2033
2034    ret = Prepare(encoderDemo, handle);
2035    ASSERT_EQ(AV_ERR_OK, ret);
2036
2037    ret = Start(encoderDemo, handle, trackId, data);
2038    ASSERT_EQ(AV_ERR_OK, ret);
2039
2040    ret = PushInputDataEOS(encoderDemo, handle, trackId);
2041    ASSERT_EQ(AV_ERR_OK, ret);
2042
2043    ret = Reset(encoderDemo, handle);
2044    ASSERT_EQ(AV_ERR_OK, ret);
2045
2046    Destroy(encoderDemo, handle);
2047    delete encoderDemo;
2048}
2049
2050/**
2051 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_058
2052 * @tc.name      : Creat -> SetCallback -> Configure -> Prepare -> Start -> Flush -> Reset
2053 * @tc.desc      : interface depend check
2054 */
2055HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_058, TestSize.Level2)
2056{
2057    OH_AVErrCode ret;
2058    uint32_t trackId = -1;
2059    uint8_t *data = nullptr;
2060
2061    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
2062    OH_AVCodec *handle = Create(encoderDemo);
2063    ASSERT_NE(nullptr, handle);
2064
2065    ret = SetCallback(encoderDemo, handle);
2066    ASSERT_EQ(AV_ERR_OK, ret);
2067
2068    ret = Configure(encoderDemo, handle);
2069    ASSERT_EQ(AV_ERR_OK, ret);
2070
2071    ret = Prepare(encoderDemo, handle);
2072    ASSERT_EQ(AV_ERR_OK, ret);
2073
2074    ret = Start(encoderDemo, handle, trackId, data);
2075    ASSERT_EQ(AV_ERR_OK, ret);
2076
2077    ret = Flush(encoderDemo, handle);
2078    ASSERT_EQ(AV_ERR_OK, ret);
2079
2080    ret = Reset(encoderDemo, handle);
2081    ASSERT_EQ(AV_ERR_OK, ret);
2082
2083    Destroy(encoderDemo, handle);
2084    delete encoderDemo;
2085}
2086
2087/**
2088 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_059
2089 * @tc.name      : Creat -> SetCallback -> Configure -> Prepare -> Start -> Stop -> Reset
2090 * @tc.desc      : interface depend check
2091 */
2092HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_059, TestSize.Level2)
2093{
2094    OH_AVErrCode ret;
2095    uint32_t trackId = -1;
2096    uint8_t *data = nullptr;
2097
2098    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
2099    OH_AVCodec *handle = Create(encoderDemo);
2100    ASSERT_NE(nullptr, handle);
2101
2102    ret = SetCallback(encoderDemo, handle);
2103    ASSERT_EQ(AV_ERR_OK, ret);
2104
2105    ret = Configure(encoderDemo, handle);
2106    ASSERT_EQ(AV_ERR_OK, ret);
2107
2108    ret = Prepare(encoderDemo, handle);
2109    ASSERT_EQ(AV_ERR_OK, ret);
2110
2111    ret = Start(encoderDemo, handle, trackId, data);
2112    ASSERT_EQ(AV_ERR_OK, ret);
2113
2114    ret = Stop(encoderDemo, handle);
2115    ASSERT_EQ(AV_ERR_OK, ret);
2116
2117    ret = Reset(encoderDemo, handle);
2118    ASSERT_EQ(AV_ERR_OK, ret);
2119
2120    Destroy(encoderDemo, handle);
2121    delete encoderDemo;
2122}
2123
2124/**
2125 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_060
2126 * @tc.name      : Creat -> SetCallback -> Configure -> Prepare -> Start -> Stop -> Reset -> Reset
2127 * @tc.desc      : interface depend check
2128 */
2129HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_060, TestSize.Level2)
2130{
2131    OH_AVErrCode ret;
2132    uint32_t trackId = -1;
2133    uint8_t *data = nullptr;
2134
2135    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
2136    OH_AVCodec *handle = Create(encoderDemo);
2137    ASSERT_NE(nullptr, handle);
2138
2139    ret = SetCallback(encoderDemo, handle);
2140    ASSERT_EQ(AV_ERR_OK, ret);
2141
2142    ret = Configure(encoderDemo, handle);
2143    ASSERT_EQ(AV_ERR_OK, ret);
2144
2145    ret = Prepare(encoderDemo, handle);
2146    ASSERT_EQ(AV_ERR_OK, ret);
2147
2148    ret = Start(encoderDemo, handle, trackId, data);
2149    ASSERT_EQ(AV_ERR_OK, ret);
2150
2151    ret = Stop(encoderDemo, handle);
2152    ASSERT_EQ(AV_ERR_OK, ret);
2153
2154    ret = Reset(encoderDemo, handle);
2155    ASSERT_EQ(AV_ERR_OK, ret);
2156
2157    ret = Reset(encoderDemo, handle);
2158    ASSERT_EQ(AV_ERR_OK, ret);
2159
2160    Destroy(encoderDemo, handle);
2161    delete encoderDemo;
2162}
2163
2164/**
2165 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_061
2166 * @tc.name      : Creat -> Destory
2167 * @tc.desc      : interface depend check
2168 */
2169HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_061, TestSize.Level2)
2170{
2171    OH_AVErrCode ret;
2172
2173    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
2174    OH_AVCodec *handle = Create(encoderDemo);
2175    ASSERT_NE(nullptr, handle);
2176
2177    ret = Destroy(encoderDemo, handle);
2178    ASSERT_EQ(AV_ERR_OK, ret);
2179    delete encoderDemo;
2180}
2181
2182/**
2183 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_062
2184 * @tc.name      : Creat -> SetCallback -> Configure -> Prepare -> Destory
2185 * @tc.desc      : interface depend check
2186 */
2187HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_062, TestSize.Level2)
2188{
2189    OH_AVErrCode ret;
2190
2191    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
2192    OH_AVCodec *handle = Create(encoderDemo);
2193    ASSERT_NE(nullptr, handle);
2194
2195    ret = SetCallback(encoderDemo, handle);
2196    ASSERT_EQ(AV_ERR_OK, ret);
2197
2198    ret = Configure(encoderDemo, handle);
2199    ASSERT_EQ(AV_ERR_OK, ret);
2200
2201    ret = Prepare(encoderDemo, handle);
2202    ASSERT_EQ(AV_ERR_OK, ret);
2203
2204    ret = Destroy(encoderDemo, handle);
2205    ASSERT_EQ(AV_ERR_OK, ret);
2206    delete encoderDemo;
2207}
2208
2209/**
2210 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_063
2211 * @tc.name      : Creat -> SetCallback -> Configure -> Prepare -> Start -> Destory
2212 * @tc.desc      : interface depend check
2213 */
2214HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_063, TestSize.Level2)
2215{
2216    OH_AVErrCode ret;
2217    uint32_t trackId = -1;
2218    uint8_t *data = nullptr;
2219
2220    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
2221    OH_AVCodec *handle = Create(encoderDemo);
2222    ASSERT_NE(nullptr, handle);
2223
2224    ret = SetCallback(encoderDemo, handle);
2225    ASSERT_EQ(AV_ERR_OK, ret);
2226
2227    ret = Configure(encoderDemo, handle);
2228    ASSERT_EQ(AV_ERR_OK, ret);
2229
2230    ret = Prepare(encoderDemo, handle);
2231    ASSERT_EQ(AV_ERR_OK, ret);
2232
2233    ret = Start(encoderDemo, handle, trackId, data);
2234    ASSERT_EQ(AV_ERR_OK, ret);
2235
2236    ret = Destroy(encoderDemo, handle);
2237    ASSERT_EQ(AV_ERR_OK, ret);
2238    delete encoderDemo;
2239}
2240
2241/**
2242 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_064
2243 * @tc.name      : Creat -> SetCallback -> Configure -> Prepare -> Start -> PushInputData -> Destory
2244 * @tc.desc      : interface depend check
2245 */
2246HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_064, TestSize.Level2)
2247{
2248    OH_AVErrCode ret;
2249    uint32_t trackId = -1;
2250    uint8_t *data = nullptr;
2251
2252    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
2253    OH_AVCodec *handle = Create(encoderDemo);
2254    ASSERT_NE(nullptr, handle);
2255
2256    ret = SetCallback(encoderDemo, handle);
2257    ASSERT_EQ(AV_ERR_OK, ret);
2258
2259    ret = Configure(encoderDemo, handle);
2260    ASSERT_EQ(AV_ERR_OK, ret);
2261
2262    ret = Prepare(encoderDemo, handle);
2263    ASSERT_EQ(AV_ERR_OK, ret);
2264
2265    ret = Start(encoderDemo, handle, trackId, data);
2266    ASSERT_EQ(AV_ERR_OK, ret);
2267
2268    ret = PushInputData(encoderDemo, handle, trackId);
2269    ASSERT_EQ(AV_ERR_OK, ret);
2270
2271    ret = Destroy(encoderDemo, handle);
2272    ASSERT_EQ(AV_ERR_OK, ret);
2273    delete encoderDemo;
2274}
2275
2276/**
2277 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_065
2278 * @tc.name      : Creat -> SetCallback -> Configure -> Prepare -> Start -> PushInputData[EOS] -> Destory
2279 * @tc.desc      : interface depend check
2280 */
2281HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_065, TestSize.Level2)
2282{
2283    OH_AVErrCode ret;
2284    uint32_t trackId = -1;
2285    uint8_t *data = nullptr;
2286
2287    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
2288    OH_AVCodec *handle = Create(encoderDemo);
2289    ASSERT_NE(nullptr, handle);
2290
2291    ret = SetCallback(encoderDemo, handle);
2292    ASSERT_EQ(AV_ERR_OK, ret);
2293
2294    ret = Configure(encoderDemo, handle);
2295    ASSERT_EQ(AV_ERR_OK, ret);
2296
2297    ret = Prepare(encoderDemo, handle);
2298    ASSERT_EQ(AV_ERR_OK, ret);
2299
2300    ret = Start(encoderDemo, handle, trackId, data);
2301    ASSERT_EQ(AV_ERR_OK, ret);
2302
2303    ret = PushInputDataEOS(encoderDemo, handle, trackId);
2304    ASSERT_EQ(AV_ERR_OK, ret);
2305
2306    ret = Destroy(encoderDemo, handle);
2307    ASSERT_EQ(AV_ERR_OK, ret);
2308    delete encoderDemo;
2309}
2310
2311/**
2312 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_066
2313 * @tc.name      : Creat -> SetCallback -> Configure -> Prepare -> Start -> Flush -> Destory
2314 * @tc.desc      : interface depend check
2315 */
2316HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_066, TestSize.Level2)
2317{
2318    OH_AVErrCode ret;
2319    uint32_t trackId = -1;
2320    uint8_t *data = nullptr;
2321
2322    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
2323    OH_AVCodec *handle = Create(encoderDemo);
2324    ASSERT_NE(nullptr, handle);
2325
2326    ret = SetCallback(encoderDemo, handle);
2327    ASSERT_EQ(AV_ERR_OK, ret);
2328
2329    ret = Configure(encoderDemo, handle);
2330    ASSERT_EQ(AV_ERR_OK, ret);
2331
2332    ret = Prepare(encoderDemo, handle);
2333    ASSERT_EQ(AV_ERR_OK, ret);
2334
2335    ret = Start(encoderDemo, handle, trackId, data);
2336    ASSERT_EQ(AV_ERR_OK, ret);
2337
2338    ret = Flush(encoderDemo, handle);
2339    ASSERT_EQ(AV_ERR_OK, ret);
2340
2341    ret = Destroy(encoderDemo, handle);
2342    ASSERT_EQ(AV_ERR_OK, ret);
2343    delete encoderDemo;
2344}
2345
2346/**
2347 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_067
2348 * @tc.name      : Creat -> SetCallback -> Configure -> Prepare -> Start -> Stop -> Destory
2349 * @tc.desc      : interface depend check
2350 */
2351HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_067, TestSize.Level2)
2352{
2353    OH_AVErrCode ret;
2354    uint32_t trackId = -1;
2355    uint8_t *data = nullptr;
2356
2357    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
2358    OH_AVCodec *handle = Create(encoderDemo);
2359    ASSERT_NE(nullptr, handle);
2360
2361    ret = SetCallback(encoderDemo, handle);
2362    ASSERT_EQ(AV_ERR_OK, ret);
2363
2364    ret = Configure(encoderDemo, handle);
2365    ASSERT_EQ(AV_ERR_OK, ret);
2366
2367    ret = Prepare(encoderDemo, handle);
2368    ASSERT_EQ(AV_ERR_OK, ret);
2369
2370    ret = Start(encoderDemo, handle, trackId, data);
2371    ASSERT_EQ(AV_ERR_OK, ret);
2372
2373    ret = Stop(encoderDemo, handle);
2374    ASSERT_EQ(AV_ERR_OK, ret);
2375
2376    ret = Destroy(encoderDemo, handle);
2377    ASSERT_EQ(AV_ERR_OK, ret);
2378    delete encoderDemo;
2379}
2380
2381/**
2382 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_068
2383 * @tc.name      : Creat -> SetCallback -> Configure -> Prepare -> Start -> Stop -> Reset -> Destory
2384 * @tc.desc      : interface depend check
2385 */
2386HWTEST_F(NativeInterfaceDependCheckTest, SUB_MULTIMEDIA_AUDIO_ENCODER_INTERFACE_DEPEND_CHECK_068, TestSize.Level2)
2387{
2388    OH_AVErrCode ret;
2389    uint32_t trackId = -1;
2390    uint8_t *data = nullptr;
2391
2392    AudioEncoderDemo *encoderDemo = new AudioEncoderDemo();
2393    OH_AVCodec *handle = Create(encoderDemo);
2394    ASSERT_NE(nullptr, handle);
2395
2396    ret = SetCallback(encoderDemo, handle);
2397    ASSERT_EQ(AV_ERR_OK, ret);
2398
2399    ret = Configure(encoderDemo, handle);
2400    ASSERT_EQ(AV_ERR_OK, ret);
2401
2402    ret = Prepare(encoderDemo, handle);
2403    ASSERT_EQ(AV_ERR_OK, ret);
2404
2405    ret = Start(encoderDemo, handle, trackId, data);
2406    ASSERT_EQ(AV_ERR_OK, ret);
2407
2408    ret = Stop(encoderDemo, handle);
2409    ASSERT_EQ(AV_ERR_OK, ret);
2410
2411    ret = Reset(encoderDemo, handle);
2412    ASSERT_EQ(AV_ERR_OK, ret);
2413
2414    ret = Destroy(encoderDemo, handle);
2415    ASSERT_EQ(AV_ERR_OK, ret);
2416    delete encoderDemo;
2417}