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 #include <atomic>
16 #include <iostream>
17 #include <fstream>
18 #include <queue>
19 #include <string>
20 #include <thread>
21 #include "gtest/gtest.h"
22 #include "avcodec_audio_avbuffer_encoder_demo.h"
23
24 using namespace std;
25 using namespace testing::ext;
26 using namespace OHOS;
27 using namespace OHOS::MediaAVCodec;
28 using namespace OHOS::MediaAVCodec::AudioAacEncDemo;
29
30 namespace {
31 class NullCheckTest : public testing::Test {
32 public:
33 static void SetUpTestCase();
34 static void TearDownTestCase();
35 void SetUp() override;
36 void TearDown() override;
37 };
38
SetUpTestCase()39 void NullCheckTest::SetUpTestCase() {}
TearDownTestCase()40 void NullCheckTest::TearDownTestCase() {}
SetUp()41 void NullCheckTest::SetUp() {}
TearDown()42 void NullCheckTest::TearDown() {}
43
44 } // namespace
45
46 /**
47 * @tc.number : NULL_CHECK_001
48 * @tc.name : CreateByMime - mime null check
49 * @tc.desc : null check test
50 */
51 HWTEST_F(NullCheckTest, NULL_CHECK_001, TestSize.Level2)
52 {
53 OH_AVCodec *codec = nullptr;
54 OH_AVErrCode result0;
55 AudioBufferAacEncDemo *audioBufferAacEncDemo = new AudioBufferAacEncDemo();
56 codec = audioBufferAacEncDemo->CreateByMime(nullptr);
57 ASSERT_EQ(codec, nullptr);
58 result0 = audioBufferAacEncDemo->Destroy(codec);
59 ASSERT_NE(result0, AV_ERR_OK);
60 delete audioBufferAacEncDemo;
61 }
62
63 /**
64 * @tc.number : NULL_CHECK_002
65 * @tc.name : CreateByName - mime null check
66 * @tc.desc : null check test
67 */
68 HWTEST_F(NullCheckTest, NULL_CHECK_002, TestSize.Level2)
69 {
70 OH_AVCodec *codec = nullptr;
71 OH_AVErrCode result0;
72 AudioBufferAacEncDemo *audioBufferAacEncDemo = new AudioBufferAacEncDemo();
73 codec = audioBufferAacEncDemo->CreateByName(nullptr);
74 ASSERT_EQ(codec, nullptr);
75 result0 = audioBufferAacEncDemo->Destroy(codec);
76 ASSERT_NE(result0, AV_ERR_OK);
77 delete audioBufferAacEncDemo;
78 }
79
80 /**
81 * @tc.number : NULL_CHECK_003
82 * @tc.name : Destroy - codec null check
83 * @tc.desc : null check test
84 */
85 HWTEST_F(NullCheckTest, NULL_CHECK_003, TestSize.Level2)
86 {
87 OH_AVCodec *codec = nullptr;
88 OH_AVErrCode result0;
89 AudioBufferAacEncDemo *audioBufferAacEncDemo = new AudioBufferAacEncDemo();
90 codec = audioBufferAacEncDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
91 ASSERT_NE(codec, nullptr);
92 result0 = audioBufferAacEncDemo->Destroy(nullptr);
93 ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
94 result0 = audioBufferAacEncDemo->Destroy(codec);
95 ASSERT_EQ(result0, AV_ERR_OK);
96 delete audioBufferAacEncDemo;
97 }
98
99 /**
100 * @tc.number : NULL_CHECK_004
101 * @tc.name : SetCallback - codec null check
102 * @tc.desc : null check test
103 */
104 HWTEST_F(NullCheckTest, NULL_CHECK_004, TestSize.Level2)
105 {
106 OH_AVCodec *codec = nullptr;
107 OH_AVErrCode result0;
108 AudioBufferAacEncDemo *audioBufferAacEncDemo = new AudioBufferAacEncDemo();
109 codec = audioBufferAacEncDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
110 ASSERT_NE(codec, nullptr);
111 result0 = audioBufferAacEncDemo->SetCallback(nullptr);
112 ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
113 result0 = audioBufferAacEncDemo->Destroy(codec);
114 ASSERT_EQ(result0, AV_ERR_OK);
115 delete audioBufferAacEncDemo;
116 }
117
118 /**
119 * @tc.number : NULL_CHECK_005
120 * @tc.name : Configure - codec null check
121 * @tc.desc : null check test
122 */
123 HWTEST_F(NullCheckTest, NULL_CHECK_005, TestSize.Level2)
124 {
125 OH_AVCodec *codec = nullptr;
126 OH_AVFormat *format = OH_AVFormat_Create();
127 int32_t channel = 1; //channel1
128 int32_t sampleRate = 8000; // 8000hz
129 int64_t bitRate = 64000; //64K
130 int32_t sampleFormat = SAMPLE_S16LE;
131 int32_t sampleBit = 16;
132 int32_t complexity = 10;
133 OH_AVErrCode result0;
134 AudioBufferAacEncDemo *audioBufferAacEncDemo = new AudioBufferAacEncDemo();
135 codec = audioBufferAacEncDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
136 ASSERT_NE(codec, nullptr);
137 result0 = audioBufferAacEncDemo->SetCallback(codec);
138 ASSERT_EQ(result0, AV_ERR_OK);
139 result0 = audioBufferAacEncDemo->Configure(nullptr, format, channel, sampleRate, bitRate, sampleFormat, sampleBit,
140 complexity);
141 ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
142 result0 = audioBufferAacEncDemo->Destroy(codec);
143 ASSERT_EQ(result0, AV_ERR_OK);
144 delete audioBufferAacEncDemo;
145 }
146
147 /**
148 * @tc.number : NULL_CHECK_006
149 * @tc.name : Configure - format null check
150 * @tc.desc : null check test
151 */
152 HWTEST_F(NullCheckTest, NULL_CHECK_006, TestSize.Level2)
153 {
154 OH_AVCodec *codec = nullptr;
155 OH_AVFormat *format = OH_AVFormat_Create();
156 int32_t channel = 1; //channel1
157 int32_t sampleRate = 8000; // 8000hz
158 int64_t bitRate = 64000; //64K
159 int32_t sampleFormat = SAMPLE_S16LE;
160 int32_t sampleBit = 16;
161 int32_t complexity = 10;
162 OH_AVErrCode result0;
163 AudioBufferAacEncDemo *audioBufferAacEncDemo = new AudioBufferAacEncDemo();
164 codec = audioBufferAacEncDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
165 ASSERT_NE(codec, nullptr);
166 result0 = audioBufferAacEncDemo->SetCallback(codec);
167 ASSERT_EQ(result0, AV_ERR_OK);
168 format = nullptr;
169 result0 = audioBufferAacEncDemo->Configure(codec, format, channel, sampleRate, bitRate, sampleFormat, sampleBit,
170 complexity);
171 ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
172 result0 = audioBufferAacEncDemo->Destroy(codec);
173 ASSERT_EQ(result0, AV_ERR_OK);
174 delete audioBufferAacEncDemo;
175 }
176
177 /**
178 * @tc.number : NULL_CHECK_007
179 * @tc.name : Prepare - codec null check
180 * @tc.desc : null check test
181 */
182 HWTEST_F(NullCheckTest, NULL_CHECK_007, TestSize.Level2)
183 {
184 OH_AVCodec *codec = nullptr;
185 OH_AVErrCode result0;
186 AudioBufferAacEncDemo *audioBufferAacEncDemo = new AudioBufferAacEncDemo();
187 codec = audioBufferAacEncDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
188 ASSERT_NE(codec, nullptr);
189 result0 = audioBufferAacEncDemo->Prepare(nullptr);
190 ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
191 result0 = audioBufferAacEncDemo->Destroy(codec);
192 ASSERT_EQ(result0, AV_ERR_OK);
193 delete audioBufferAacEncDemo;
194 }
195
196 /**
197 * @tc.number : NULL_CHECK_008
198 * @tc.name : Start - codec null check
199 * @tc.desc : null check test
200 */
201 HWTEST_F(NullCheckTest, NULL_CHECK_008, TestSize.Level2)
202 {
203 OH_AVCodec *codec = nullptr;
204 OH_AVFormat *format = OH_AVFormat_Create();
205 int32_t channel = 1; //channel1
206 int32_t sampleRate = 8000; // 8000hz
207 int64_t bitRate = 64000; //64K
208 int32_t sampleFormat = SAMPLE_S16LE;
209 int32_t sampleBit = 16;
210 int32_t complexity = 10;
211 OH_AVErrCode result0;
212 AudioBufferAacEncDemo *audioBufferAacEncDemo = new AudioBufferAacEncDemo();
213 codec = audioBufferAacEncDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
214 ASSERT_NE(codec, nullptr);
215 result0 = audioBufferAacEncDemo->SetCallback(codec);
216 ASSERT_EQ(result0, AV_ERR_OK);
217 result0 = audioBufferAacEncDemo->Configure(codec, format, channel, sampleRate, bitRate, sampleFormat, sampleBit,
218 complexity);
219 ASSERT_EQ(result0, AV_ERR_OK);
220 result0 = audioBufferAacEncDemo->Start(nullptr);
221 ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
222 result0 = audioBufferAacEncDemo->Destroy(codec);
223 ASSERT_EQ(result0, AV_ERR_OK);
224 delete audioBufferAacEncDemo;
225 }
226
227 /**
228 * @tc.number : NULL_CHECK_009
229 * @tc.name : Stop - codec null check
230 * @tc.desc : null check test
231 */
232 HWTEST_F(NullCheckTest, NULL_CHECK_009, TestSize.Level2)
233 {
234 OH_AVCodec *codec = nullptr;
235 OH_AVFormat *format = OH_AVFormat_Create();
236 int32_t channel = 1; //channel1
237 int32_t sampleRate = 8000; // 8000hz
238 int64_t bitRate = 64000; //64K
239 int32_t sampleFormat = SAMPLE_S16LE;
240 int32_t sampleBit = 16;
241 int32_t complexity = 10;
242 OH_AVErrCode result0;
243 AudioBufferAacEncDemo *audioBufferAacEncDemo = new AudioBufferAacEncDemo();
244 codec = audioBufferAacEncDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
245 ASSERT_NE(codec, nullptr);
246 result0 = audioBufferAacEncDemo->SetCallback(codec);
247 ASSERT_EQ(result0, AV_ERR_OK);
248 result0 = audioBufferAacEncDemo->Configure(codec, format, channel, sampleRate, bitRate, sampleFormat, sampleBit,
249 complexity);
250 ASSERT_EQ(result0, AV_ERR_OK);
251 result0 = audioBufferAacEncDemo->Start(codec);
252 ASSERT_EQ(result0, AV_ERR_OK);
253 result0 = audioBufferAacEncDemo->Stop(nullptr);
254 ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
255 result0 = audioBufferAacEncDemo->Destroy(codec);
256 ASSERT_EQ(result0, AV_ERR_OK);
257 delete audioBufferAacEncDemo;
258 }
259
260 /**
261 * @tc.number : NULL_CHECK_010
262 * @tc.name : Flush - codec null check
263 * @tc.desc : null check test
264 */
265 HWTEST_F(NullCheckTest, NULL_CHECK_010, TestSize.Level2)
266 {
267 OH_AVCodec *codec = nullptr;
268 OH_AVFormat *format = OH_AVFormat_Create();
269 int32_t channel = 1; //channel1
270 int32_t sampleRate = 8000; // 8000hz
271 int64_t bitRate = 64000; //64K
272 int32_t sampleFormat = SAMPLE_S16LE;
273 int32_t sampleBit = 16;
274 int32_t complexity = 10;
275 OH_AVErrCode result0;
276 AudioBufferAacEncDemo *audioBufferAacEncDemo = new AudioBufferAacEncDemo();
277 codec = audioBufferAacEncDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
278 ASSERT_NE(codec, nullptr);
279 result0 = audioBufferAacEncDemo->SetCallback(codec);
280 ASSERT_EQ(result0, AV_ERR_OK);
281 result0 = audioBufferAacEncDemo->Configure(codec, format, channel, sampleRate, bitRate, sampleFormat, sampleBit,
282 complexity);
283 ASSERT_EQ(result0, AV_ERR_OK);
284 result0 = audioBufferAacEncDemo->Start(codec);
285 ASSERT_EQ(result0, AV_ERR_OK);
286 result0 = audioBufferAacEncDemo->Flush(nullptr);
287 ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
288 result0 = audioBufferAacEncDemo->Destroy(codec);
289 ASSERT_EQ(result0, AV_ERR_OK);
290 delete audioBufferAacEncDemo;
291 }
292
293 /**
294 * @tc.number : NULL_CHECK_011
295 * @tc.name : Reset - codec null check
296 * @tc.desc : null check test
297 */
298 HWTEST_F(NullCheckTest, NULL_CHECK_011, TestSize.Level2)
299 {
300 OH_AVCodec *codec = nullptr;
301 OH_AVErrCode result0;
302 AudioBufferAacEncDemo *audioBufferAacEncDemo = new AudioBufferAacEncDemo();
303 codec = audioBufferAacEncDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
304 ASSERT_NE(codec, nullptr);
305 result0 = audioBufferAacEncDemo->Reset(nullptr);
306 ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
307 result0 = audioBufferAacEncDemo->Destroy(codec);
308 ASSERT_EQ(result0, AV_ERR_OK);
309 delete audioBufferAacEncDemo;
310 }
311
312 /**
313 * @tc.number : NULL_CHECK_012
314 * @tc.name : GetOutputDescription - codec null check
315 * @tc.desc : null check test
316 */
317 HWTEST_F(NullCheckTest, NULL_CHECK_012, TestSize.Level2)
318 {
319 OH_AVCodec *codec = nullptr;
320 OH_AVFormat *format = OH_AVFormat_Create();
321 int32_t channel = 1; //channel1
322 int32_t sampleRate = 8000; // 8000hz
323 int64_t bitRate = 64000; //64K
324 int32_t sampleFormat = SAMPLE_S16LE;
325 int32_t sampleBit = 16;
326 int32_t complexity = 10;
327 OH_AVErrCode result0;
328 OH_AVFormat *result1;
329 AudioBufferAacEncDemo *audioBufferAacEncDemo = new AudioBufferAacEncDemo();
330 codec = audioBufferAacEncDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
331 ASSERT_NE(codec, nullptr);
332 result0 = audioBufferAacEncDemo->SetCallback(codec);
333 ASSERT_EQ(result0, AV_ERR_OK);
334 result0 = audioBufferAacEncDemo->Configure(codec, format, channel, sampleRate, bitRate, sampleFormat, sampleBit,
335 complexity);
336 ASSERT_EQ(result0, AV_ERR_OK);
337 result0 = audioBufferAacEncDemo->Start(codec);
338 ASSERT_EQ(result0, AV_ERR_OK);
339 result1 = audioBufferAacEncDemo->GetOutputDescription(nullptr);
340 ASSERT_EQ(result1, nullptr);
341 result0 = audioBufferAacEncDemo->Destroy(codec);
342 ASSERT_EQ(result0, AV_ERR_OK);
343 delete audioBufferAacEncDemo;
344 }
345
346 /**
347 * @tc.number : NULL_CHECK_013
348 * @tc.name : PushInputData - codec null check
349 * @tc.desc : null check test
350 */
351 HWTEST_F(NullCheckTest, NULL_CHECK_013, TestSize.Level2)
352 {
353 OH_AVCodec *codec = nullptr;
354 OH_AVFormat *format = OH_AVFormat_Create();
355 int32_t channel = 1; //channel1
356 int32_t sampleRate = 8000; // 8000hz
357 int64_t bitRate = 64000; //64K
358 int32_t sampleFormat = SAMPLE_S16LE;
359 int32_t sampleBit = 16;
360 int32_t complexity = 10;
361 uint32_t index;
362 OH_AVErrCode result0;
363 AudioBufferAacEncDemo *audioBufferAacEncDemo = new AudioBufferAacEncDemo();
364 codec = audioBufferAacEncDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
365 ASSERT_NE(codec, nullptr);
366 result0 = audioBufferAacEncDemo->SetCallback(codec);
367 ASSERT_EQ(result0, AV_ERR_OK);
368 result0 = audioBufferAacEncDemo->Configure(codec, format, channel, sampleRate, bitRate, sampleFormat, sampleBit,
369 complexity);
370 ASSERT_EQ(result0, AV_ERR_OK);
371 result0 = audioBufferAacEncDemo->Start(codec);
372 ASSERT_EQ(result0, AV_ERR_OK);
373 index = audioBufferAacEncDemo->GetInputIndex();
374 result0 = audioBufferAacEncDemo->PushInputData(nullptr, index);
375 ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
376 result0 = audioBufferAacEncDemo->Destroy(codec);
377 ASSERT_EQ(result0, AV_ERR_OK);
378 delete audioBufferAacEncDemo;
379 }
380
381 /**
382 * @tc.number : NULL_CHECK_014
383 * @tc.name : PushInputDataEOS - codec null check
384 * @tc.desc : null check test
385 */
386 HWTEST_F(NullCheckTest, NULL_CHECK_014, TestSize.Level2)
387 {
388 OH_AVCodec *codec = nullptr;
389 OH_AVFormat *format = OH_AVFormat_Create();
390 int32_t channel = 1; //channel1
391 int32_t sampleRate = 8000; // 8000hz
392 int64_t bitRate = 64000; //64K
393 int32_t sampleFormat = SAMPLE_S16LE;
394 int32_t sampleBit = 16;
395 int32_t complexity = 10;
396 uint32_t index;
397 OH_AVErrCode result0;
398 AudioBufferAacEncDemo *audioBufferAacEncDemo = new AudioBufferAacEncDemo();
399 codec = audioBufferAacEncDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
400 ASSERT_NE(codec, nullptr);
401 result0 = audioBufferAacEncDemo->SetCallback(codec);
402 ASSERT_EQ(result0, AV_ERR_OK);
403 result0 = audioBufferAacEncDemo->Configure(codec, format, channel, sampleRate, bitRate, sampleFormat, sampleBit,
404 complexity);
405 ASSERT_EQ(result0, AV_ERR_OK);
406 result0 = audioBufferAacEncDemo->Start(codec);
407 ASSERT_EQ(result0, AV_ERR_OK);
408 index = audioBufferAacEncDemo->GetInputIndex();
409 result0 = audioBufferAacEncDemo->PushInputDataEOS(nullptr, index);
410 ASSERT_NE(result0, AV_ERR_OK);
411 result0 = audioBufferAacEncDemo->Destroy(codec);
412 ASSERT_EQ(result0, AV_ERR_OK);
413 delete audioBufferAacEncDemo;
414 }
415
416 /**
417 * @tc.number : NULL_CHECK_015
418 * @tc.name : FreeOutputData - codec null check
419 * @tc.desc : null check test
420 */
421 HWTEST_F(NullCheckTest, NULL_CHECK_015, TestSize.Level2)
422 {
423 OH_AVCodec *codec = nullptr;
424 OH_AVFormat *format = OH_AVFormat_Create();
425 int32_t channel = 1; //channel1
426 int32_t sampleRate = 8000; // 8000hz
427 int64_t bitRate = 64000; //64K
428 int32_t sampleFormat = SAMPLE_S16LE;
429 int32_t sampleBit = 16;
430 int32_t complexity = 10;
431 uint32_t index;
432 OH_AVErrCode result0;
433 AudioBufferAacEncDemo *audioBufferAacEncDemo = new AudioBufferAacEncDemo();
434 codec = audioBufferAacEncDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
435 ASSERT_NE(codec, nullptr);
436 result0 = audioBufferAacEncDemo->SetCallback(codec);
437 ASSERT_EQ(result0, AV_ERR_OK);
438 result0 = audioBufferAacEncDemo->Configure(codec, format, channel, sampleRate, bitRate, sampleFormat, sampleBit,
439 complexity);
440 ASSERT_EQ(result0, AV_ERR_OK);
441 result0 = audioBufferAacEncDemo->Start(codec);
442 ASSERT_EQ(result0, AV_ERR_OK);
443 index = audioBufferAacEncDemo->GetInputIndex();
444 index = -1;
445 result0 = audioBufferAacEncDemo->PushInputDataEOS(codec, index);
446 ASSERT_NE(result0, AV_ERR_OK);
447 index = audioBufferAacEncDemo->GetOutputIndex();
448 result0 = audioBufferAacEncDemo->FreeOutputData(nullptr, index);
449 ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
450 result0 = audioBufferAacEncDemo->Destroy(codec);
451 ASSERT_EQ(result0, AV_ERR_OK);
452 delete audioBufferAacEncDemo;
453 }
454
455 /**
456 * @tc.number : NULL_CHECK_016
457 * @tc.name : IsValid - codec null check
458 * @tc.desc : null check test
459 */
460 HWTEST_F(NullCheckTest, NULL_CHECK_016, TestSize.Level2)
461 {
462 OH_AVCodec *codec = nullptr;
463 bool *isValid = nullptr;
464 OH_AVErrCode result0;
465 AudioBufferAacEncDemo *audioBufferAacEncDemo = new AudioBufferAacEncDemo();
466 codec = audioBufferAacEncDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
467 ASSERT_NE(codec, nullptr);
468 result0 = audioBufferAacEncDemo->IsValid(nullptr, isValid);
469 ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
470 result0 = audioBufferAacEncDemo->Destroy(codec);
471 ASSERT_EQ(result0, AV_ERR_OK);
472 delete audioBufferAacEncDemo;
473 }
474
475 /**
476 * @tc.number : NULL_CHECK_017
477 * @tc.name : IsValid - isValid null check
478 * @tc.desc : null check test
479 */
480 HWTEST_F(NullCheckTest, NULL_CHECK_017, TestSize.Level2)
481 {
482 OH_AVCodec *codec = nullptr;
483 bool *isValid = nullptr;
484 OH_AVErrCode result0;
485 AudioBufferAacEncDemo *audioBufferAacEncDemo = new AudioBufferAacEncDemo();
486 codec = audioBufferAacEncDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
487 ASSERT_NE(codec, nullptr);
488 isValid = nullptr;
489 result0 = audioBufferAacEncDemo->IsValid(codec, isValid);
490 ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
491 result0 = audioBufferAacEncDemo->Destroy(codec);
492 ASSERT_EQ(result0, AV_ERR_OK);
493 delete audioBufferAacEncDemo;
494 }
495
496 /**
497 * @tc.number : NULL_CHECK_018
498 * @tc.name : NULL_CHECK_018
499 * @tc.desc : OH_AudioCodec_QueryInputBuffer - codec null check
500 */
501 HWTEST_F(NullCheckTest, NULL_CHECK_018, TestSize.Level2)
502 {
503 OH_AVCodec *codec = nullptr;
504 OH_AVFormat* format = nullptr;
505 int32_t channel = 1; //channel1
506 int32_t sampleRate = 8000; // 8000hz
507 int64_t bitRate = 64000; //64K
508 int32_t sampleFormat = SAMPLE_S16LE;
509 int32_t syncMode = 1;
510 int64_t timeoutUs = 2000000;
511 uint32_t index = 0;
512 OH_AVErrCode result0;
513 AudioBufferAacEncDemo *audioBufferEncDemo = new AudioBufferAacEncDemo();
514 codec = audioBufferEncDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
515 ASSERT_NE(codec, nullptr);
516 format = OH_AVFormat_Create();
517 result0 = audioBufferEncDemo->Configure(codec, format, channel, sampleRate, bitRate, sampleFormat, syncMode);
518 ASSERT_EQ(result0, AV_ERR_OK);
519 result0 = audioBufferEncDemo->Start(codec);
520 ASSERT_EQ(result0, AV_ERR_OK);
521 result0 = OH_AudioCodec_QueryInputBuffer(nullptr, &index, timeoutUs);
522 ASSERT_NE(result0, AV_ERR_OK);
523 result0 = OH_AudioCodec_Stop(codec);
524 ASSERT_EQ(result0, AV_ERR_OK);
525 result0 = audioBufferEncDemo->Destroy(codec);
526 ASSERT_EQ(result0, AV_ERR_OK);
527 OH_AVFormat_Destroy(format);
528 format = nullptr;
529 codec = nullptr;
530 delete audioBufferEncDemo;
531 }
532
533 /**
534 * @tc.number : NULL_CHECK_019
535 * @tc.name : NULL_CHECK_019
536 * @tc.desc : OH_AudioCodec_QueryInputBuffer - index null check
537 */
538 HWTEST_F(NullCheckTest, NULL_CHECK_019, TestSize.Level2)
539 {
540 OH_AVCodec *codec = nullptr;
541 OH_AVFormat* format = nullptr;
542 int32_t channel = 1; //channel1
543 int32_t sampleRate = 8000; // 8000hz
544 int64_t bitRate = 64000; //64K
545 int32_t sampleFormat = SAMPLE_S16LE;
546 int32_t syncMode = 1;
547 int64_t timeoutUs = 2000000;
548 OH_AVErrCode result0;
549 AudioBufferAacEncDemo *audioBufferEncDemo = new AudioBufferAacEncDemo();
550 codec = audioBufferEncDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
551 ASSERT_NE(codec, nullptr);
552 format = OH_AVFormat_Create();
553 result0 = audioBufferEncDemo->Configure(codec, format, channel, sampleRate, bitRate, sampleFormat, syncMode);
554 ASSERT_EQ(result0, AV_ERR_OK);
555 result0 = audioBufferEncDemo->Start(codec);
556 ASSERT_EQ(result0, AV_ERR_OK);
557 result0 = OH_AudioCodec_QueryInputBuffer(codec, nullptr, timeoutUs);
558 ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
559 result0 = OH_AudioCodec_Stop(codec);
560 ASSERT_EQ(result0, AV_ERR_OK);
561 result0 = audioBufferEncDemo->Destroy(codec);
562 ASSERT_EQ(result0, AV_ERR_OK);
563 OH_AVFormat_Destroy(format);
564 format = nullptr;
565 codec = nullptr;
566 delete audioBufferEncDemo;
567 }
568
569 /**
570 * @tc.number : NULL_CHECK_020
571 * @tc.name : NULL_CHECK_020
572 * @tc.desc : OH_AudioCodec_GetInputBuffer - codec null check
573 */
574 HWTEST_F(NullCheckTest, NULL_CHECK_020, TestSize.Level2)
575 {
576 OH_AVCodec *codec = nullptr;
577 OH_AVFormat* format = nullptr;
578 OH_AVBuffer* buffer = nullptr;
579 int32_t channel = 1; //channel1
580 int32_t sampleRate = 8000; // 8000hz
581 int64_t bitRate = 64000; //64K
582 int32_t sampleFormat = SAMPLE_S16LE;
583 int32_t syncMode = 1;
584 int64_t timeoutUs = 2000000;
585 uint32_t index = 0;
586 OH_AVErrCode result0;
587 AudioBufferAacEncDemo *audioBufferEncDemo = new AudioBufferAacEncDemo();
588 codec = audioBufferEncDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
589 ASSERT_NE(codec, nullptr);
590 format = OH_AVFormat_Create();
591 result0 = audioBufferEncDemo->Configure(codec, format, channel, sampleRate, bitRate, sampleFormat, syncMode);
592 ASSERT_EQ(result0, AV_ERR_OK);
593 result0 = audioBufferEncDemo->Start(codec);
594 ASSERT_EQ(result0, AV_ERR_OK);
595 result0 = OH_AudioCodec_QueryInputBuffer(codec, &index, timeoutUs);
596 ASSERT_EQ(result0, AV_ERR_OK);
597 buffer = OH_AudioCodec_GetInputBuffer(nullptr, index);
598 ASSERT_EQ(buffer, nullptr);
599 result0 = OH_AudioCodec_Stop(codec);
600 ASSERT_EQ(result0, AV_ERR_OK);
601 result0 = audioBufferEncDemo->Destroy(codec);
602 ASSERT_EQ(result0, AV_ERR_OK);
603 OH_AVFormat_Destroy(format);
604 format = nullptr;
605 codec = nullptr;
606 delete audioBufferEncDemo;
607 }
608
609 /**
610 * @tc.number : NULL_CHECK_021
611 * @tc.name : NULL_CHECK_021
612 * @tc.desc : OH_AudioCodec_QueryOutputBuffer - codec null check
613 */
614 HWTEST_F(NullCheckTest, NULL_CHECK_021, TestSize.Level2)
615 {
616 OH_AVCodec *codec = nullptr;
617 OH_AVFormat* format = nullptr;
618 OH_AVBuffer* buffer = nullptr;
619 int32_t channel = 1; //channel1
620 int32_t sampleRate = 8000; // 8000hz
621 int64_t bitRate = 64000; //64K
622 int32_t sampleFormat = SAMPLE_S16LE;
623 int32_t syncMode = 1;
624 int64_t timeoutUs = 2000000;
625 uint32_t index = 0;
626 OH_AVErrCode result0;
627 AudioBufferAacEncDemo *audioBufferEncDemo = new AudioBufferAacEncDemo();
628 codec = audioBufferEncDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
629 ASSERT_NE(codec, nullptr);
630 format = OH_AVFormat_Create();
631 result0 = audioBufferEncDemo->Configure(codec, format, channel, sampleRate, bitRate, sampleFormat, syncMode);
632 ASSERT_EQ(result0, AV_ERR_OK);
633 result0 = audioBufferEncDemo->Start(codec);
634 ASSERT_EQ(result0, AV_ERR_OK);
635 result0 = OH_AudioCodec_QueryInputBuffer(codec, &index, timeoutUs);
636 ASSERT_EQ(result0, AV_ERR_OK);
637 buffer = OH_AudioCodec_GetInputBuffer(codec, index);
638 ASSERT_NE(buffer, nullptr);
639 OH_AVCodecBufferAttr attr;
640 memset_s(&attr, sizeof(attr), 0, sizeof(attr));
641 attr.size = 0;
642 attr.flags = AVCODEC_BUFFER_FLAGS_EOS;
643 result0 = OH_AVBuffer_SetBufferAttr(buffer, &attr);
644 ASSERT_EQ(result0, AV_ERR_OK);
645 result0 = OH_AudioCodec_PushInputBuffer(codec, index);
646 ASSERT_EQ(result0, AV_ERR_OK);
647 result0 = OH_AudioCodec_QueryOutputBuffer(nullptr, &index, timeoutUs);
648 ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
649 result0 = OH_AudioCodec_Stop(codec);
650 ASSERT_EQ(result0, AV_ERR_OK);
651 result0 = audioBufferEncDemo->Destroy(codec);
652 ASSERT_EQ(result0, AV_ERR_OK);
653 OH_AVFormat_Destroy(format);
654 format = nullptr;
655 codec = nullptr;
656 delete audioBufferEncDemo;
657 }
658
659 /**
660 * @tc.number : NULL_CHECK_022
661 * @tc.name : NULL_CHECK_022
662 * @tc.desc : OH_AudioCodec_QueryOutputBuffer - index null check
663 */
664 HWTEST_F(NullCheckTest, NULL_CHECK_022, TestSize.Level2)
665 {
666 OH_AVCodec *codec = nullptr;
667 OH_AVFormat* format = nullptr;
668 OH_AVBuffer* buffer = nullptr;
669 int32_t channel = 1; //channel1
670 int32_t sampleRate = 8000; // 8000hz
671 int64_t bitRate = 64000; //64K
672 int32_t sampleFormat = SAMPLE_S16LE;
673 int32_t syncMode = 1;
674 int64_t timeoutUs = 2000000;
675 uint32_t index = 0;
676 OH_AVErrCode result0;
677 AudioBufferAacEncDemo *audioBufferEncDemo = new AudioBufferAacEncDemo();
678 codec = audioBufferEncDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
679 ASSERT_NE(codec, nullptr);
680 format = OH_AVFormat_Create();
681 result0 = audioBufferEncDemo->Configure(codec, format, channel, sampleRate, bitRate, sampleFormat, syncMode);
682 ASSERT_EQ(result0, AV_ERR_OK);
683 result0 = audioBufferEncDemo->Start(codec);
684 ASSERT_EQ(result0, AV_ERR_OK);
685 result0 = OH_AudioCodec_QueryInputBuffer(codec, &index, timeoutUs);
686 ASSERT_EQ(result0, AV_ERR_OK);
687 buffer = OH_AudioCodec_GetInputBuffer(codec, index);
688 ASSERT_NE(buffer, nullptr);
689 OH_AVCodecBufferAttr attr;
690 memset_s(&attr, sizeof(attr), 0, sizeof(attr));
691 attr.size = 0;
692 attr.flags = AVCODEC_BUFFER_FLAGS_EOS;
693 result0 = OH_AVBuffer_SetBufferAttr(buffer, &attr);
694 ASSERT_EQ(result0, AV_ERR_OK);
695 result0 = OH_AudioCodec_PushInputBuffer(codec, index);
696 ASSERT_EQ(result0, AV_ERR_OK);
697 result0 = OH_AudioCodec_QueryOutputBuffer(codec, nullptr, timeoutUs);
698 ASSERT_EQ(result0, AV_ERR_INVALID_VAL);
699 result0 = OH_AudioCodec_Stop(codec);
700 ASSERT_EQ(result0, AV_ERR_OK);
701 result0 = audioBufferEncDemo->Destroy(codec);
702 ASSERT_EQ(result0, AV_ERR_OK);
703 OH_AVFormat_Destroy(format);
704 format = nullptr;
705 codec = nullptr;
706 delete audioBufferEncDemo;
707 }
708
709 /**
710 * @tc.number : NULL_CHECK_023
711 * @tc.name : NULL_CHECK_023
712 * @tc.desc : OH_AudioCodec_GetOutputBuffer - codec null check
713 */
714 HWTEST_F(NullCheckTest, NULL_CHECK_023, TestSize.Level2)
715 {
716 OH_AVCodec *codec = nullptr;
717 OH_AVFormat* format = nullptr;
718 OH_AVBuffer* buffer = nullptr;
719 int32_t channel = 1; //channel1
720 int32_t sampleRate = 8000; // 8000hz
721 int64_t bitRate = 64000; //64K
722 int32_t sampleFormat = SAMPLE_S16LE;
723 int32_t syncMode = 1;
724 int64_t timeoutUs = 2000000;
725 uint32_t index = 0;
726 OH_AVErrCode result0;
727 AudioBufferAacEncDemo *audioBufferEncDemo = new AudioBufferAacEncDemo();
728 codec = audioBufferEncDemo->CreateByMime(OH_AVCODEC_MIMETYPE_AUDIO_G711MU);
729 ASSERT_NE(codec, nullptr);
730 format = OH_AVFormat_Create();
731 result0 = audioBufferEncDemo->Configure(codec, format, channel, sampleRate, bitRate, sampleFormat, syncMode);
732 ASSERT_EQ(result0, AV_ERR_OK);
733 result0 = audioBufferEncDemo->Start(codec);
734 ASSERT_EQ(result0, AV_ERR_OK);
735 result0 = OH_AudioCodec_QueryInputBuffer(codec, &index, timeoutUs);
736 ASSERT_EQ(result0, AV_ERR_OK);
737 buffer = OH_AudioCodec_GetInputBuffer(codec, index);
738 ASSERT_NE(buffer, nullptr);
739 OH_AVCodecBufferAttr attr;
740 memset_s(&attr, sizeof(attr), 0, sizeof(attr));
741 attr.size = 0;
742 attr.flags = AVCODEC_BUFFER_FLAGS_EOS;
743 result0 = OH_AVBuffer_SetBufferAttr(buffer, &attr);
744 ASSERT_EQ(result0, AV_ERR_OK);
745 result0 = OH_AudioCodec_PushInputBuffer(codec, index);
746 ASSERT_EQ(result0, AV_ERR_OK);
747 result0 = OH_AudioCodec_QueryOutputBuffer(codec, &index, timeoutUs);
748 ASSERT_EQ(result0, AV_ERR_OK);
749 buffer = OH_AudioCodec_GetOutputBuffer(nullptr, index);
750 ASSERT_EQ(buffer, nullptr);
751 result0 = OH_AudioCodec_Stop(codec);
752 ASSERT_EQ(result0, AV_ERR_OK);
753 result0 = audioBufferEncDemo->Destroy(codec);
754 ASSERT_EQ(result0, AV_ERR_OK);
755 OH_AVFormat_Destroy(format);
756 format = nullptr;
757 codec = nullptr;
758 delete audioBufferEncDemo;
759 }