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