• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1/*
2 * Copyright (c) 2023 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
16import { describe, it, expect } from "@ohos/hypium"
17import audioDecoderAvBuffer from 'libaudioDecoderAvBuffer.so'
18
19export default function audioDeCoderNdkTest() {
20  describe('audioDecoderAvBufferTest', () => {
21
22    /**
23     * @tc.number     : SUB_MULTIMEDIA_AV_CODEC_AUDIODECODER_OH_AUDIOCODEC_CREATEBYMime_0100
24     * @tc.name       : testOhAudioDecoderCreateByMime001
25     * @tc.desc       : test OH_AudioCodec_CreateByMime
26     * @tc.size       : MediumTest
27     * @tc.type       : Function
28     * @tc.level      : Level 0
29     */
30    it('testOhAudioDecoderCreateByMime001', 0, async (done: Function) => {
31      expect(audioDecoderAvBuffer.OH_AudioCodec_CreateByMime()).assertEqual(0);
32      done();
33    });
34
35    /**
36     * @tc.number     : SUB_MULTIMEDIA_AV_CODEC_AUDIODECODER_OH_AUDIOCODEC_CREATEBYMime_0200
37     * @tc.name       : testOhAudioDecoderCreateByMime002
38     * @tc.desc       : test OH_AudioCodec_CreateByMime
39     * @tc.size       : MediumTest
40     * @tc.type       : Function
41     * @tc.level      : Level 0
42     */
43    it('testOhAudioDecoderCreateByMime002', 0, async (done: Function) => {
44      expect(audioDecoderAvBuffer.OHAudioDecoderAmrnb()).assertEqual(0);
45      done();
46    });
47
48    /**
49     * @tc.number     : SUB_MULTIMEDIA_AV_CODEC_AUDIODECODER_OH_AUDIOCODEC_CREATEBYMime_0300
50     * @tc.name       : testOhAudioDecoderCreateByMime003
51     * @tc.desc       : test OH_AudioCodec_CreateByMime
52     * @tc.size       : MediumTest
53     * @tc.type       : Function
54     * @tc.level      : Level 0
55     */
56    it('testOhAudioDecoderCreateByMime003', 0, async (done: Function) => {
57      expect(audioDecoderAvBuffer.OHAudioDecoderAmrwb()).assertEqual(0);
58      done();
59    });
60
61    /**
62     * @tc.number     : SUB_MULTIMEDIA_AV_CODEC_AUDIODECODER_OH_AUDIOCODEC_CREATEBYMime_0400
63     * @tc.name       : testOhAudioDecoderCreateByMime004
64     * @tc.desc       : test OH_AudioCodec_CreateByMime
65     * @tc.size       : MediumTest
66     * @tc.type       : Function
67     * @tc.level      : Level 0
68     */
69    it('testOhAudioDecoderCreateByMime004', 0, async (done: Function) => {
70      expect(audioDecoderAvBuffer.OHAudioDecoderOpus()).assertEqual(0);
71      done();
72    });
73
74    /**
75     * @tc.number     : SUB_MULTIMEDIA_AV_CODEC_AUDIODECODER_OH_AUDIOCODEC_CREATEBYMime_0500
76     * @tc.name       : testOhAudioDecoderCreateByMime005
77     * @tc.desc       : test OH_AudioCodec_CreateByMime
78     * @tc.size       : MediumTest
79     * @tc.type       : Function
80     * @tc.level      : Level 0
81     */
82    it('testOhAudioDecoderCreateByMime005', 0, async (done: Function) => {
83      expect(audioDecoderAvBuffer.OHAudioDecoderG711Mu()).assertEqual(0);
84      done();
85    });
86
87    /**
88     * @tc.number     : SUB_MULTIMEDIA_AV_CODEC_AUDIODECODER_OH_AUDIOCODEC_CREATEBYMime_0600
89     * @tc.name       : testOhAudioDecoderCreateByMime006
90     * @tc.desc       : test OH_AudioCodec_CreateByMime
91     * @tc.size       : MediumTest
92     * @tc.type       : Function
93     * @tc.level      : Level 0
94     */
95    it('testOhAudioDecoderCreateByMime006', 0, async (done: Function) => {
96      expect(audioDecoderAvBuffer.OHAudioDecoderViVid()).assertEqual(0);
97      done();
98    });
99
100    /**
101     * @tc.number     : SUB_MULTIMEDIA_AV_CODEC_AUDIODECODER_OH_AUDIOCODEC_CREATEBYNAME_0100
102     * @tc.name       : testOhAudioDecoderCreateByName001
103     * @tc.desc       : test OH_AudioCodec_CreateByName
104     * @tc.size       : MediumTest
105     * @tc.type       : Function
106     * @tc.level      : Level 0
107     */
108    it('testOhAudioDecoderCreateByName001', 0, async (done: Function) => {
109      expect(audioDecoderAvBuffer.OH_AudioCodec_CreateByName()).assertEqual(0);
110      done();
111    });
112
113    /**
114     * @tc.number     : SUB_MULTIMEDIA_AV_CODEC_AUDIODECODER_OH_AUDIOCODEC_DESTROY_0100
115     * @tc.name       : testOhAudioDecoderDestroy001
116     * @tc.desc       : test OH_AudioCodec_Destroy
117     * @tc.size       : MediumTest
118     * @tc.type       : Function
119     * @tc.level      : Level 0
120     */
121    it('testOhAudioDecoderDestroy001', 0, async (done: Function) => {
122      expect(audioDecoderAvBuffer.OH_AudioCodec_Destroy()).assertEqual(0);
123      done();
124    });
125
126    /**
127     * @tc.number     : SUB_MULTIMEDIA_AV_CODEC_AUDIODECODER_OH_AUDIOCODEC_REGISTERCALLBACK_0100
128     * @tc.name       : testOhAudioDecoderRegisterCallback001
129     * @tc.desc       : test OH_AudioCodec_RegisterCallback
130     * @tc.size       : MediumTest
131     * @tc.type       : Function
132     * @tc.level      : Level 0
133     */
134    it('testOhAudioDecoderSetCallback001', 0, async (done: Function) => {
135      expect(audioDecoderAvBuffer.OH_AudioCodec_RegisterCallback()).assertEqual(0);
136      done();
137    });
138
139    /**
140     * @tc.number     : SUB_MULTIMEDIA_AV_CODEC_AUDIODECODER_OH_AUDIOCODEC_CONFIGURE_0100
141     * @tc.name       : testOhAudioDecoderConfigure001
142     * @tc.desc       : test OH_AudioCodec_Configure
143     * @tc.size       : MediumTest
144     * @tc.type       : Function
145     * @tc.level      : Level 0
146     */
147    it('testOhAudioDecoderConfigure001', 0, async (done: Function) => {
148      expect(audioDecoderAvBuffer.OH_AudioCodec_Configure()).assertEqual(0);
149      done();
150    });
151
152    /**
153     * @tc.number     : SUB_MULTIMEDIA_AV_CODEC_AUDIODECODER_OH_AUDIOCODEC_PREPARE_0100
154     * @tc.name       : testOhAudioDecoderPrepare001
155     * @tc.desc       : test OH_AudioCodec_Prepare
156     * @tc.size       : MediumTest
157     * @tc.type       : Function
158     * @tc.level      : Level 0
159     */
160    it('testOhAudioDecoderPrepare001', 0, async (done: Function) => {
161      expect(audioDecoderAvBuffer.OH_AudioCodec_Prepare()).assertEqual(0);
162      done();
163    });
164
165    /**
166     * @tc.number     : SUB_MULTIMEDIA_AV_CODEC_AUDIODECODER_OH_AUDIOCODEC_START_0100
167     * @tc.name       : testOhAudioDecoderStart001
168     * @tc.desc       : test OH_AudioCodec_Start
169     * @tc.size       : MediumTest
170     * @tc.type       : Function
171     * @tc.level      : Level 0
172     */
173    it('testOhAudioDecoderStart001', 0, async (done: Function) => {
174      expect(audioDecoderAvBuffer.OH_AudioCodec_Start()).assertEqual(0);
175      done();
176    });
177
178    /**
179     * @tc.number     : SUB_MULTIMEDIA_AV_CODEC_AUDIODECODER_OH_AUDIOCODEC_STOP_0100
180     * @tc.name       : testOhAudioDecoderStop001
181     * @tc.desc       : test OH_AudioCodec_Stop
182     * @tc.size       : MediumTest
183     * @tc.type       : Function
184     * @tc.level      : Level 0
185     */
186    it('testOhAudioDecoderStop001', 0, async (done: Function) => {
187      expect(audioDecoderAvBuffer.OH_AudioCodec_Stop()).assertEqual(0);
188      done();
189    });
190
191    /**
192     * @tc.number     : SUB_MULTIMEDIA_AV_CODEC_AUDIODECODER_OH_AUDIOCODEC_FLUSH_0100
193     * @tc.name       : testOhAudioDecoderFlush001
194     * @tc.desc       : test OH_AudioCodec_Flush
195     * @tc.size       : MediumTest
196     * @tc.type       : Function
197     * @tc.level      : Level 0
198     */
199    it('testOhAudioDecoderFlush001', 0, async (done: Function) => {
200      expect(audioDecoderAvBuffer.OH_AudioCodec_Flush()).assertEqual(0);
201      done();
202    });
203
204    /**
205     * @tc.number     : SUB_MULTIMEDIA_AV_CODEC_AUDIODECODER_OH_AUDIOCODEC_RESET_0100
206     * @tc.name       : testOhAudioDecoderReset001
207     * @tc.desc       : test OH_AudioCodec_Reset
208     * @tc.size       : MediumTest
209     * @tc.type       : Function
210     * @tc.level      : Level 0
211     */
212    it('testOhAudioDecoderReset001', 0, async (done: Function) => {
213      expect(audioDecoderAvBuffer.OH_AudioCodec_Reset()).assertEqual(0);
214      done();
215    });
216
217    /**
218     * @tc.number     : SUB_MULTIMEDIA_AV_CODEC_AUDIODECODER_OH_AUDIOCODEC_GETOUTPUTDESCRIPTION_0100
219     * @tc.name       : testOhAudioDecoderGetOutputDescription001
220     * @tc.desc       : test OH_AudioCodec_GetOutputDescription
221     * @tc.size       : MediumTest
222     * @tc.type       : Function
223     * @tc.level      : Level 0
224     */
225    it('testOhAudioDecoderGetOutputDescription001', 0, async (done: Function) => {
226      expect(audioDecoderAvBuffer.OH_AudioCodec_GetOutputDescription()).assertEqual(0);
227      done();
228    });
229
230    /**
231     * @tc.number     : SUB_MULTIMEDIA_AV_CODEC_AUDIODECODER_OH_AUDIOCODEC_SETPARAMETER_0100
232     * @tc.name       : testOhAudioDecoderSetParameter001
233     * @tc.desc       : test OH_AudioCodec_SetParameter
234     * @tc.size       : MediumTest
235     * @tc.type       : Function
236     * @tc.level      : Level 0
237     */
238    it('testOhAudioDecoderSetParameter001', 0, async (done: Function) => {
239      expect(audioDecoderAvBuffer.OH_AudioCodec_SetParameter()).assertEqual(0);
240      done();
241    });
242
243    /**
244     * @tc.number     : SUB_MULTIMEDIA_AV_CODEC_AUDIODECODER_OH_AUDIOCODEC_ISVALID_0100
245     * @tc.name       : testOhAudioDecoderIsValid001
246     * @tc.desc       : test OH_AudioCodec_IsValid
247     * @tc.size       : MediumTest
248     * @tc.type       : Function
249     * @tc.level      : Level 0
250     */
251    it('testOhAudioDecoderIsValid001', 0, async (done: Function) => {
252      expect(audioDecoderAvBuffer.OH_AudioCodec_IsValid()).assertEqual(0);
253      done();
254    });
255
256    /**
257     * @tc.number     : SUB_MULTIMEDIA_AV_CODEC_AUDIODECODER_OH_AUDIOCODEC_CREATEBYNAME_0200
258     * @tc.name       : testOHAudioDecoderCreateByName002
259     * @tc.desc       : test OH_AudioCodec_CreateByName
260     * @tc.size       : MediumTest
261     * @tc.type       : Function
262     * @tc.level      : Level 1
263     */
264    it('testOHAudioDecoderCreateByName002', 0, async (done: Function) => {
265      let result: number = audioDecoderAvBuffer.OHAudioDecoderCreateByNameAnormal();
266      expect(result).assertEqual(0);
267      done();
268    });
269
270    /**
271     * @tc.number     : SUB_MULTIMEDIA_AV_CODEC_AUDIODECODER_OH_AUDIOCODEC_CREATEBYNAME_0300
272     * @tc.name       : testOHAudioDecoderCreateByName003
273     * @tc.desc       : test OH_AudioCodec_CreateByName
274     * @tc.size       : MediumTest
275     * @tc.type       : Function
276     * @tc.level      : Level 1
277     */
278    it('testOHAudioDecoderCreateByName003', 0, async (done: Function) => {
279      let result: number = audioDecoderAvBuffer.OHAudioDecoderCreateByNameBnormal();
280      expect(result).assertEqual(0);
281      done();
282    });
283
284    /**
285     * @tc.number     : SUB_MULTIMEDIA_AV_CODEC_AUDIODECODER_OH_AUDIOCODEC_CREATEBYNAME_0400
286     * @tc.name       : testOHAudioDecoderCreateByName004
287     * @tc.desc       : test OH_AudioCodec_CreateByName
288     * @tc.size       : MediumTest
289     * @tc.type       : Function
290     * @tc.level      : Level 1
291     */
292    it('testOHAudioDecoderCreateByName004', 0, async (done: Function) => {
293      let result: number = audioDecoderAvBuffer.OHAudioDecoderCreateByNameCnormal();
294      expect(result).assertEqual(0);
295      done();
296    });
297
298    /**
299     * @tc.number     : SUB_MULTIMEDIA_AV_CODEC_AUDIODECODER_OH_AUDIOCODEC_DESTROY_0200
300     * @tc.name       : testOHAudioDecoderDestroy002
301     * @tc.desc       : test OH_AudioCodec_Destroy
302     * @tc.size       : MediumTest
303     * @tc.type       : Function
304     * @tc.level      : Level 1
305     */
306    it('testOHAudioDecoderDestroy002', 0, async (done: Function) => {
307      let result: number = audioDecoderAvBuffer.OHAudioDecoderDestroyAnormal();
308      expect(result).assertEqual(0);
309      done();
310    });
311
312    /**
313     * @tc.number     : SUB_MULTIMEDIA_AV_CODEC_AUDIODECODER_OH_AUDIOCODEC_DESTROY_0300
314     * @tc.name       : testOHAudioDecoderDestroy003
315     * @tc.desc       : test OH_AudioCodec_Destroy
316     * @tc.size       : MediumTest
317     * @tc.type       : Function
318     * @tc.level      : Level 1
319     */
320    it('testOHAudioDecoderDestroy003', 0, async (done: Function) => {
321      let result: number = audioDecoderAvBuffer.OHAudioDecoderDestroyBnormal();
322      expect(result).assertEqual(0);
323      done();
324    });
325
326    /**
327     * @tc.number     : SUB_MULTIMEDIA_AV_CODEC_AUDIODECODER_OH_AUDIOCODEC_DESTROY_0400
328     * @tc.name       : testOHAudioDecoderDestroy004
329     * @tc.desc       : test OH_AudioCodec_Destroy
330     * @tc.size       : MediumTest
331     * @tc.type       : Function
332     * @tc.level      : Level 1
333     */
334    it('testOHAudioDecoderDestroy004', 0, async (done: Function) => {
335      let result: number = audioDecoderAvBuffer.OHAudioDecoderDestroyCnormal();
336      expect(result).assertEqual(0);
337      done();
338    });
339
340    /**
341     * @tc.number     : SUB_MULTIMEDIA_AV_CODEC_AUDIODECODER_OH_AUDIOCODEC_START_0200
342     * @tc.name       : testOHAudioDecoderStart002
343     * @tc.desc       : test OH_AudioCodec_Start
344     * @tc.size       : MediumTest
345     * @tc.type       : Function
346     * @tc.level      : Level 1
347     */
348    it('testOHAudioDecoderStart002', 0, async (done: Function) => {
349      let result: number = audioDecoderAvBuffer.OHAudioDecoderStartAnormal();
350      expect(result).assertEqual(0);
351      done();
352    });
353
354    /**
355     * @tc.number     : SUB_MULTIMEDIA_AV_CODEC_AUDIODECODER_OH_AUDIOCODEC_START_0300
356     * @tc.name       : testOHAudioDecoderStart003
357     * @tc.desc       : test OH_AudioCodec_Start
358     * @tc.size       : MediumTest
359     * @tc.type       : Function
360     * @tc.level      : Level 1
361     */
362    it('testOHAudioDecoderStart003', 0, async (done: Function) => {
363      let result: number = audioDecoderAvBuffer.OHAudioDecoderStartBnormal();
364      expect(result).assertEqual(0);
365      done();
366    });
367
368     /**
369     * @tc.number     : SUB_MULTIMEDIA_AV_CODEC_AUDIODECODER_OH_AUDIOCODEC_START_0400
370     * @tc.name       : testOHAudioDecoderStart004
371     * @tc.desc       : test OH_AudioCodec_Start
372     * @tc.size       : MediumTest
373     * @tc.type       : Function
374     * @tc.level      : Level 1
375     */
376    it('testOHAudioDecoderStart004', 0, async (done: Function) => {
377      let result: number = audioDecoderAvBuffer.OHAudioDecoderStartCnormal();
378      expect(result).assertEqual(-1);
379      done();
380    });
381
382    /**
383     * @tc.number     : SUB_MULTIMEDIA_AV_CODEC_AUDIODECODER_OH_AUDIOCODEC_STOP_0200
384     * @tc.name       : testOHAudioDecoderStop002
385     * @tc.desc       : test OH_AudioCodec_Stop
386     * @tc.size       : MediumTest
387     * @tc.type       : Function
388     * @tc.level      : Level 1
389     */
390    it('testOHAudioDecoderStop002', 0, async (done: Function) => {
391      let result: number = audioDecoderAvBuffer.OHAudioDecoderStopAnormal();
392      expect(result).assertEqual(0);
393      done();
394    });
395
396    /**
397     * @tc.number     : SUB_MULTIMEDIA_AV_CODEC_AUDIODECODER_OH_AUDIOCODEC_STOP_0300
398     * @tc.name       : testOHAudioDecoderStop003
399     * @tc.desc       : test OH_AudioCodec_Stop
400     * @tc.size       : MediumTest
401     * @tc.type       : Function
402     * @tc.level      : Level 1
403     */
404    it('testOHAudioDecoderStop003', 0, async (done: Function) => {
405      let result: number = audioDecoderAvBuffer.OHAudioDecoderStopBnormal();
406      expect(result).assertEqual(0);
407      done();
408    });
409
410    /**
411     * @tc.number     : SUB_MULTIMEDIA_AV_CODEC_AUDIODECODER_OH_AUDIOCODEC_STOP_0400
412     * @tc.name       : testOHAudioDecoderStop004
413     * @tc.desc       : test OH_AudioCodec_Stop
414     * @tc.size       : MediumTest
415     * @tc.type       : Function
416     * @tc.level      : Level 1
417     */
418    it('testOHAudioDecoderStop004', 0, async (done: Function) => {
419      let result: number = audioDecoderAvBuffer.OHAudioDecoderStopCnormal();
420      expect(result).assertEqual(-1);
421      done();
422    });
423
424    /**
425     * @tc.number     : SUB_MULTIMEDIA_AV_CODEC_AUDIODECODER_OH_AUDIOCODEC_FLUSH_0200
426     * @tc.name       : testOHAudioDecoderFlush002
427     * @tc.desc       : test OH_AudioCodec_Flush
428     * @tc.size       : MediumTest
429     * @tc.type       : Function
430     * @tc.level      : Level 1
431     */
432    it('testOHAudioDecoderFlush002', 0, async (done: Function) => {
433      let result: number = audioDecoderAvBuffer.OHAudioDecoderFlushAnormal();
434      expect(result).assertEqual(0);
435      done();
436    });
437
438    /**
439     * @tc.number     : SUB_MULTIMEDIA_AV_CODEC_AUDIODECODER_OH_AUDIOCODEC_FLUSH_0300
440     * @tc.name       : testOHAudioDecoderFlush003
441     * @tc.desc       : test OH_AudioCodec_Flush
442     * @tc.size       : MediumTest
443     * @tc.type       : Function
444     * @tc.level      : Level 1
445     */
446    it('testOHAudioDecoderFlush003', 0, async (done: Function) => {
447      let result: number = audioDecoderAvBuffer.OHAudioDecoderFlushBnormal();
448      expect(result).assertEqual(0);
449      done();
450    });
451
452    /**
453     * @tc.number     : SUB_MULTIMEDIA_AV_CODEC_AUDIODECODER_OH_AUDIOCODEC_FLUSH_0400
454     * @tc.name       : testOHAudioDecoderFlush004
455     * @tc.desc       : test OH_AudioCodec_Flush
456     * @tc.size       : MediumTest
457     * @tc.type       : Function
458     * @tc.level      : Level 1
459     */
460    it('testOHAudioDecoderFlush004', 0, async (done: Function) => {
461      let result: number = audioDecoderAvBuffer.OHAudioDecoderFlushCnormal();
462      expect(result).assertEqual(-1);
463      done();
464    });
465
466    /**
467     * @tc.number     : SUB_MULTIMEDIA_AV_CODEC_AUDIODECODER_OH_AUDIOCODEC_RESET_0200
468     * @tc.name       : testOHAudioDecoderReset002
469     * @tc.desc       : test OH_AudioCodec_Reset
470     * @tc.size       : MediumTest
471     * @tc.type       : Function
472     * @tc.level      : Level 1
473     */
474    it('testOHAudioDecoderReset002', 0, async (done: Function) => {
475      let result: number = audioDecoderAvBuffer.OHAudioDecoderResetAnormal();
476      expect(result).assertEqual(0);
477      done();
478    });
479
480    /**
481     * @tc.number     : SUB_MULTIMEDIA_AV_CODEC_AUDIODECODER_OH_AUDIOCODEC_RESET_0300
482     * @tc.name       : testOHAudioDecoderReset003
483     * @tc.desc       : test OH_AudioCodec_Reset
484     * @tc.size       : MediumTest
485     * @tc.type       : Function
486     * @tc.level      : Level 1
487     */
488    it('testOHAudioDecoderReset003', 0, async (done: Function) => {
489      let result: number = audioDecoderAvBuffer.OHAudioDecoderResetBnormal();
490      expect(result).assertEqual(0);
491      done();
492    });
493
494    /**
495     * @tc.number     : SUB_MULTIMEDIA_AV_CODEC_AUDIODECODER_OH_AUDIOCODEC_RESET_0400
496     * @tc.name       : testOHAudioDecoderReset004
497     * @tc.desc       : test OH_AudioCodec_Reset
498     * @tc.size       : MediumTest
499     * @tc.type       : Function
500     * @tc.level      : Level 1
501     */
502    it('testOHAudioDecoderReset004', 0, async (done: Function) => {
503      let result: number = audioDecoderAvBuffer.OHAudioDecoderResetCnormal();
504      expect(result).assertEqual(-1);
505      done();
506    });
507
508     /**
509     * @tc.number     : SUB_MULTIMEDIA_AV_CODEC_AUDIODECODER_OH_AUDIOCODEC_GETOUTPUTDESCRIPTION_0200
510     * @tc.name       : testOHAudioDecoderGetOutputDescription002
511     * @tc.desc       : test OH_AudioCodec_GetOutputDescription
512     * @tc.size       : MediumTest
513     * @tc.type       : Function
514     * @tc.level      : Level 1
515     */
516    it('testOHAudioDecoderGetOutputDescription002', 0, async (done: Function) => {
517      let result: number = audioDecoderAvBuffer.OHAudioDecoderGetOutputDescriptionAnormal();
518      expect(result).assertEqual(0);
519      done();
520    });
521
522    /**
523     * @tc.number     : SUB_MULTIMEDIA_AV_CODEC_AUDIODECODER_OH_AUDIOCODEC_GETOUTPUTDESCRIPTION_0300
524     * @tc.name       : testOHAudioDecoderGetOutputDescription003
525     * @tc.desc       : test OH_AudioCodec_GetOutputDescription
526     * @tc.size       : MediumTest
527     * @tc.type       : Function
528     * @tc.level      : Level 1
529     */
530    it('testOHAudioDecoderGetOutputDescription003', 0, async (done: Function) => {
531      let result: number = audioDecoderAvBuffer.OHAudioDecoderGetOutputDescriptionBnormal();
532      expect(result).assertEqual(0);
533      done();
534    });
535
536    /**
537     * @tc.number     : SUB_MULTIMEDIA_AV_CODEC_AUDIODECODER_OH_AUDIOCODEC_GETOUTPUTDESCRIPTION_0400
538     * @tc.name       : testOHAudioDecoderGetOutputDescription004
539     * @tc.desc       : test OH_AudioCodec_GetOutputDescription
540     * @tc.size       : MediumTest
541     * @tc.type       : Function
542     * @tc.level      : Level 1
543     */
544    it('testOHAudioDecoderGetOutputDescription004', 0, async (done: Function) => {
545      let result: number = audioDecoderAvBuffer.OHAudioDecoderGetOutputDescriptionCnormal();
546      expect(result).assertEqual(-1);
547      done();
548    });
549
550    /**
551     * @tc.number     : SUB_MULTIMEDIA_AV_CODEC_AUDIODECODER_OH_AUDIOCODEC_SETPARAMETER_0200
552     * @tc.name       : testOHAudioDecoderSetParameter002
553     * @tc.desc       : test OH_AudioCodec_SetParameter
554     * @tc.size       : MediumTest
555     * @tc.type       : Function
556     * @tc.level      : Level 1
557     */
558    it('testOHAudioDecoderSetParameter002', 0, async (done: Function) => {
559      let result: number = audioDecoderAvBuffer.OHAudioDecoderSetParameterAnormal();
560      expect(result).assertEqual(0);
561      done();
562    });
563
564    /**
565     * @tc.number     : SUB_MULTIMEDIA_AV_CODEC_AUDIODECODER_OH_AUDIOCODEC_SETPARAMETER_0300
566     * @tc.name       : testOHAudioDecoderSetParameter003
567     * @tc.desc       : test OH_AudioCodec_SetParameter
568     * @tc.size       : MediumTest
569     * @tc.type       : Function
570     * @tc.level      : Level 1
571     */
572    it('testOHAudioDecoderSetParameter003', 0, async (done: Function) => {
573      let result: number = audioDecoderAvBuffer.OHAudioDecoderSetParameterBnormal();
574      expect(result).assertEqual(0);
575      done();
576    });
577
578    /**
579     * @tc.number     : SUB_MULTIMEDIA_AV_CODEC_AUDIODECODER_OH_AUDIOCODEC_SETPARAMETER_0400
580     * @tc.name       : testOHAudioDecoderSetParameter004
581     * @tc.desc       : test OH_AudioCodec_SetParameter
582     * @tc.size       : MediumTest
583     * @tc.type       : Function
584     * @tc.level      : Level 1
585     */
586    it('testOHAudioDecoderSetParameter004', 0, async (done: Function) => {
587      let result: number = audioDecoderAvBuffer.OHAudioDecoderSetParameterCnormal();
588      expect(result).assertEqual(-1);
589      done();
590    });
591
592    /**
593     * @tc.number     : SUB_MULTIMEDIA_AV_CODEC_AUDIODECODER_OH_AUDIOCODEC_ISVALID_0200
594     * @tc.name       : testOHAudioDecoderIsValid002
595     * @tc.desc       : test OH_AudioCodec_IsValid
596     * @tc.size       : MediumTest
597     * @tc.type       : Function
598     * @tc.level      : Level 1
599     */
600    it('testOHAudioDecoderIsValid002', 0, async (done: Function) => {
601      let result: number = audioDecoderAvBuffer.OHAudioDecoderIsValidAnormal();
602      expect(result).assertEqual(0);
603      done();
604    });
605
606    /**
607     * @tc.number     : SUB_MULTIMEDIA_AV_CODEC_AUDIODECODER_OH_AUDIOCODEC_ISVALID_0300
608     * @tc.name       : testOHAudioDecoderIsValid003
609     * @tc.desc       : test OH_AudioCodec_IsValid
610     * @tc.size       : MediumTest
611     * @tc.type       : Function
612     * @tc.level      : Level 1
613     */
614    it('testOHAudioDecoderIsValid003', 0, async (done: Function) => {
615      let result: number = audioDecoderAvBuffer.OHAudioDecoderIsValidBnormal();
616      expect(result).assertEqual(0);
617      done();
618    });
619
620    /**
621     * @tc.number     : SUB_MULTIMEDIA_AV_CODEC_AUDIODECODER_OH_AUDIOCODEC_ISVALID_0400
622     * @tc.name       : testOHAudioDecoderIsValid004
623     * @tc.desc       : test OH_AudioCodec_IsValid
624     * @tc.size       : MediumTest
625     * @tc.type       : Function
626     * @tc.level      : Level 1
627     */
628    it('testOHAudioDecoderIsValid004', 0, async (done: Function) => {
629      let result: number = audioDecoderAvBuffer.OHAudioDecoderIsValidCnormal();
630      expect(result).assertEqual(-1);
631      done();
632    });
633
634    /**
635     * @tc.number     : SUB_MULTIMEDIA_AV_CODEC_AUDIODECODER_OH_AUDIOCODEC_PUSHINPUTBUFFER_0100
636     * @tc.name       : testOHAudioDecoderPushInputBuffer001
637     * @tc.desc       : test OH_AudioCodec_PushInputBuffer
638     * @tc.size       : MediumTest
639     * @tc.type       : Function
640     * @tc.level      : Level 1
641     */
642    it('testOHAudioDecoderPushInputBuffer001', 0, async (done: Function) => {
643      let result: number = audioDecoderAvBuffer.OHAudioDecoderPushInputBuffer();
644      expect(result).assertEqual(0);
645      done();
646    });
647
648    /**
649     * @tc.number     : SUB_MULTIMEDIA_AV_CODEC_AUDIODECODER_OH_AUDIOCODEC_FREEOUTPUTBUFFER_0100
650     * @tc.name       : testOHAudioDecoderFreeOutputBuffer001
651     * @tc.desc       : test OH_AudioCodec_FreeOutputBuffer
652     * @tc.size       : MediumTest
653     * @tc.type       : Function
654     * @tc.level      : Level 1
655     */
656    it('testOHAudioDecoderFreeOutputBuffer001', 0, async (done: Function) => {
657      let result: number = audioDecoderAvBuffer.OHAudioDecoderFreeOutputBuffer();
658      expect(result).assertEqual(0);
659      done();
660    });
661
662  })
663}
664