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
20 using namespace std;
21 using namespace testing::ext;
22 using namespace OHOS;
23 using namespace OHOS::MediaAVCodec;
24
25 namespace {
26 class NativeInterfaceDependCheckTest : public testing::Test {
27 public:
28 static void SetUpTestCase();
29 static void TearDownTestCase();
30 void SetUp() override;
31 void TearDown() override;
32 };
33
SetUpTestCase()34 void NativeInterfaceDependCheckTest::SetUpTestCase() {}
TearDownTestCase()35 void NativeInterfaceDependCheckTest::TearDownTestCase() {}
SetUp()36 void NativeInterfaceDependCheckTest::SetUp() {}
TearDown()37 void NativeInterfaceDependCheckTest::TearDown() {}
38
Create(AudioEncoderDemo * encoderDemo)39 OH_AVCodec *Create(AudioEncoderDemo *encoderDemo)
40 {
41 return encoderDemo->NativeCreateByName("OH.Media.Codec.Encoder.Audio.AAC");
42 }
43
Destroy(AudioEncoderDemo * encoderDemo,OH_AVCodec * handle)44 OH_AVErrCode Destroy(AudioEncoderDemo *encoderDemo, OH_AVCodec *handle)
45 {
46 return encoderDemo->NativeDestroy(handle);
47 }
48
SetCallback(AudioEncoderDemo * encoderDemo,OH_AVCodec * handle)49 OH_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
Configure(AudioEncoderDemo * encoderDemo,OH_AVCodec * handle)56 OH_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
Prepare(AudioEncoderDemo * encoderDemo,OH_AVCodec * handle)76 OH_AVErrCode Prepare(AudioEncoderDemo *encoderDemo, OH_AVCodec *handle)
77 {
78 return encoderDemo->NativePrepare(handle);
79 }
80
Start(AudioEncoderDemo * encoderDemo,OH_AVCodec * handle,uint32_t & index,uint8_t * data)81 OH_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
Stop(AudioEncoderDemo * encoderDemo,OH_AVCodec * handle)95 OH_AVErrCode Stop(AudioEncoderDemo *encoderDemo, OH_AVCodec *handle)
96 {
97 return encoderDemo->NativeStop(handle);
98 }
99
Flush(AudioEncoderDemo * encoderDemo,OH_AVCodec * handle)100 OH_AVErrCode Flush(AudioEncoderDemo *encoderDemo, OH_AVCodec *handle)
101 {
102 return encoderDemo->NativeFlush(handle);
103 }
104
Reset(AudioEncoderDemo * encoderDemo,OH_AVCodec * handle)105 OH_AVErrCode Reset(AudioEncoderDemo *encoderDemo, OH_AVCodec *handle)
106 {
107 return encoderDemo->NativeReset(handle);
108 }
109
PushInputData(AudioEncoderDemo * encoderDemo,OH_AVCodec * handle,uint32_t index)110 OH_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
PushInputDataEOS(AudioEncoderDemo * encoderDemo,OH_AVCodec * handle,uint32_t index)122 OH_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 */
139 HWTEST_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 */
158 HWTEST_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 */
180 HWTEST_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 */
202 HWTEST_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 */
230 HWTEST_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 */
270 HWTEST_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 */
307 HWTEST_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 */
344 HWTEST_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 */
381 HWTEST_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 */
418 HWTEST_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 */
466 HWTEST_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 */
489 HWTEST_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 */
515 HWTEST_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 */
544 HWTEST_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 */
578 HWTEST_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 */
615 HWTEST_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 */
652 HWTEST_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 */
689 HWTEST_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 */
726 HWTEST_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 */
766 HWTEST_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 */
788 HWTEST_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 */
819 HWTEST_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 */
853 HWTEST_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 */
890 HWTEST_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 */
927 HWTEST_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 */
964 HWTEST_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 */
1001 HWTEST_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 */
1041 HWTEST_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 */
1062 HWTEST_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 */
1092 HWTEST_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 */
1128 HWTEST_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 */
1165 HWTEST_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 */
1202 HWTEST_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 */
1239 HWTEST_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 */
1279 HWTEST_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 */
1316 HWTEST_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 */
1356 HWTEST_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 */
1376 HWTEST_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 */
1405 HWTEST_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 */
1439 HWTEST_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 */
1476 HWTEST_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 */
1513 HWTEST_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_OK, 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 */
1550 HWTEST_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 */
1587 HWTEST_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 */
1627 HWTEST_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 */
1647 HWTEST_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_OK, 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 */
1676 HWTEST_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 */
1710 HWTEST_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 */
1747 HWTEST_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 */
1784 HWTEST_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 */
1821 HWTEST_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_OK, 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 */
1858 HWTEST_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 */
1898 HWTEST_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 */
1918 HWTEST_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 */
1947 HWTEST_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 */
1981 HWTEST_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 */
2018 HWTEST_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 */
2055 HWTEST_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 */
2092 HWTEST_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 */
2129 HWTEST_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 */
2169 HWTEST_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 */
2187 HWTEST_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 */
2214 HWTEST_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 */
2246 HWTEST_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 */
2281 HWTEST_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 */
2316 HWTEST_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 */
2351 HWTEST_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 */
2386 HWTEST_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 }