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  */
HWTEST_F(NullCheckTest, NULL_CHECK_001, TestSize.Level2)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  */
HWTEST_F(NullCheckTest, NULL_CHECK_002, TestSize.Level2)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  */
HWTEST_F(NullCheckTest, NULL_CHECK_003, TestSize.Level2)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  */
HWTEST_F(NullCheckTest, NULL_CHECK_004, TestSize.Level2)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  */
HWTEST_F(NullCheckTest, NULL_CHECK_005, TestSize.Level2)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  */
HWTEST_F(NullCheckTest, NULL_CHECK_006, TestSize.Level2)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  */
HWTEST_F(NullCheckTest, NULL_CHECK_007, TestSize.Level2)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  */
HWTEST_F(NullCheckTest, NULL_CHECK_008, TestSize.Level2)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  */
HWTEST_F(NullCheckTest, NULL_CHECK_009, TestSize.Level2)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  */
HWTEST_F(NullCheckTest, NULL_CHECK_010, TestSize.Level2)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  */
HWTEST_F(NullCheckTest, NULL_CHECK_011, TestSize.Level2)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  */
HWTEST_F(NullCheckTest, NULL_CHECK_012, TestSize.Level2)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  */
HWTEST_F(NullCheckTest, NULL_CHECK_013, TestSize.Level2)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  */
HWTEST_F(NullCheckTest, NULL_CHECK_014, TestSize.Level2)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  */
HWTEST_F(NullCheckTest, NULL_CHECK_015, TestSize.Level2)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  */
HWTEST_F(NullCheckTest, NULL_CHECK_016, TestSize.Level2)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  */
HWTEST_F(NullCheckTest, NULL_CHECK_017, TestSize.Level2)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