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 
16 #include "avbuffer_mock.h"
17 #include "avbuffer_unit_test.h"
18 #include "avbuffer_utils.h"
19 #include "common/log.h"
20 #include "common/status.h"
21 #include "unittest_log.h"
22 #ifdef AVBUFFER_CAPI_UNIT_TEST
23 #include "common/native_mfmagic.h"
24 #include "native_avbuffer.h"
25 #include "native_avformat.h"
26 #endif
27 
28 using namespace std;
29 using namespace testing::ext;
30 
31 namespace OHOS {
32 namespace Media {
33 namespace AVBufferUT {
34 /**
35  * @tc.name: AVBuffer_Create_001
36  * @tc.desc: create func test
37  * @tc.type: FUNC
38  */
39 HWTEST_F(AVBufferFrameworkUnitTest, AVBuffer_Create_001, TestSize.Level1)
40 {
41     EXPECT_EQ(static_cast<int32_t>(Status::OK), buffer_->Destroy());
42     buffer_ = nullptr;
43 
44     buffer_ = AVBufferMockFactory::CreateAVBuffer(-1);
45     EXPECT_EQ(nullptr, buffer_);
46 }
47 
48 /**
49  * @tc.name: AVBuffer_GetAddr_001
50  * @tc.desc: buffer get memory addr func test
51  * @tc.type: FUNC
52  */
53 HWTEST_F(AVBufferFrameworkUnitTest, AVBuffer_GetAddr_001, TestSize.Level1)
54 {
55     EXPECT_NE(nullptr, buffer_->GetAddr());
56 
57     EXPECT_EQ(static_cast<int32_t>(Status::OK), buffer_->Destroy());
58     buffer_ = nullptr;
59 }
60 
61 /**
62  * @tc.name: AVBuffer_GetAddr_002
63  * @tc.desc: Repeatedly getting memory addr
64  * @tc.type: FUNC
65  */
66 HWTEST_F(AVBufferFrameworkUnitTest, AVBuffer_GetAddr_002, TestSize.Level1)
67 {
68     for (int32_t i = 0; i < TEST_LOOP_DEPTH; ++i) {
69         EXPECT_NE(nullptr, buffer_->GetAddr());
70     }
71     EXPECT_EQ(static_cast<int32_t>(Status::OK), buffer_->Destroy());
72     buffer_ = nullptr;
73 }
74 
75 /**
76  * @tc.name: AVBuffer_GetCapacity_001
77  * @tc.desc: buffer get capacity func test
78  * @tc.type: FUNC
79  */
80 HWTEST_F(AVBufferFrameworkUnitTest, AVBuffer_GetCapacity_001, TestSize.Level1)
81 {
82     EXPECT_EQ(MEMSIZE, buffer_->GetCapacity());
83 
84     EXPECT_EQ(static_cast<int32_t>(Status::OK), buffer_->Destroy());
85     buffer_ = nullptr;
86 }
87 /**
88  * @tc.name: AVBuffer_GetCapacity_002
89  * @tc.desc: Repeatedly getting capacity
90  * @tc.type: FUNC
91  */
92 HWTEST_F(AVBufferFrameworkUnitTest, AVBuffer_GetCapacity_002, TestSize.Level1)
93 {
94     for (int32_t i = 0; i < TEST_LOOP_DEPTH; ++i) {
95         EXPECT_EQ(MEMSIZE, buffer_->GetCapacity());
96     }
97     EXPECT_EQ(static_cast<int32_t>(Status::OK), buffer_->Destroy());
98     buffer_ = nullptr;
99 }
100 
101 /**
102  * @tc.name: AVBuffer_SetBufferAttr_001
103  * @tc.desc: buffer get and set buffer attribute
104  * @tc.type: FUNC
105  */
106 HWTEST_F(AVBufferFrameworkUnitTest, AVBuffer_SetBufferAttr_001, TestSize.Level1)
107 {
108     OH_AVCodecBufferAttr attr;
109     attr.pts = DEFAULT_PTS;
110     attr.size = MEMSIZE;
111     attr.offset = DEFAULT_OFFSET;
112     attr.flags = DEFAULT_FLAG;
113     EXPECT_EQ(static_cast<int32_t>(Status::OK), buffer_->SetBufferAttr(attr));
114 
115     OH_AVCodecBufferAttr attrTemp;
116     EXPECT_EQ(static_cast<int32_t>(Status::OK), buffer_->GetBufferAttr(attrTemp));
117     EXPECT_EQ(attr.pts, attrTemp.pts);
118     EXPECT_EQ(attr.size, attrTemp.size);
119     EXPECT_EQ(attr.offset, attrTemp.offset);
120     EXPECT_EQ(attr.flags, attrTemp.flags);
121 
122     EXPECT_EQ(static_cast<int32_t>(Status::OK), buffer_->Destroy());
123     buffer_ = nullptr;
124 }
125 
126 /**
127  * @tc.name: AVBuffer_SetParameter_001
128  * @tc.desc: buffer get and set parameter
129  * @tc.type: FUNC
130  */
131 HWTEST_F(AVBufferFrameworkUnitTest, AVBuffer_SetParameter_001, TestSize.Level1)
132 {
133     std::shared_ptr<FormatMock> format;
134 
135     EXPECT_TRUE(format->PutIntValue(INT_CAPI_TESTKEY, INTVALUE));
136     EXPECT_TRUE(format->PutLongValue(LONG_CAPI_TESTKEY, LONGVALUE));
137     EXPECT_TRUE(format->PutFloatValue(FlOAT_CAPI_TESTKEY, FLOATVALUE));
138     EXPECT_TRUE(format->PutDoubleValue(DOUBLE_CAPI_TESTKEY, DOUBLEVALUE));
139     EXPECT_TRUE(format->PutStringValue(STRING_CAPI_TESTKEY, STRINGVALUE));
140     EXPECT_EQ(static_cast<int32_t>(Status::OK), buffer_->SetParameter(format));
141 
142     std::shared_ptr<FormatMock> formatTemp = buffer_->GetParameter();
143     int32_t getIntValue = 0;
144     int64_t getLongValue = 0;
145     float getFloatValue = 0.0;
146     double getDoubleValue = 0.0;
147     std::string getStringValue = "";
148 
149     EXPECT_TRUE(formatTemp->GetIntValue(INT_CAPI_TESTKEY, getIntValue));
150     EXPECT_TRUE(formatTemp->GetLongValue(LONG_CAPI_TESTKEY, getLongValue));
151     EXPECT_TRUE(formatTemp->GetFloatValue(FlOAT_CAPI_TESTKEY, getFloatValue));
152     EXPECT_TRUE(formatTemp->GetDoubleValue(DOUBLE_CAPI_TESTKEY, getDoubleValue));
153     EXPECT_TRUE(formatTemp->GetStringValue(STRING_CAPI_TESTKEY, getStringValue));
154 
155     EXPECT_EQ(getIntValue, INTVALUE);
156     EXPECT_EQ(getLongValue, LONGVALUE);
157     EXPECT_EQ(getFloatValue, FLOATVALUE);
158     EXPECT_EQ(getDoubleValue, DOUBLEVALUE);
159     EXPECT_EQ(getStringValue, STRINGVALUE);
160 
161     EXPECT_EQ(static_cast<int32_t>(Status::OK), buffer_->Destroy());
162     buffer_ = nullptr;
163 }
164 
165 /**
166  * @tc.name: AVBuffer_GetNativeBuffer_001
167  * @tc.desc: get native buffer
168  * @tc.type: FUNC
169  */
170 HWTEST_F(AVBufferFrameworkUnitTest, AVBuffer_GetNativeBuffer_001, TestSize.Level1)
171 {
172     EXPECT_EQ(nullptr, buffer_->GetNativeBuffer());
173     buffer_ = nullptr;
174 }
175 
176 /**
177  * @tc.name: AVBuffer_Destroy_001
178  * @tc.desc: destroy buffer
179  * @tc.type: FUNC
180  */
181 HWTEST_F(AVBufferFrameworkUnitTest, AVBuffer_Destroy_001, TestSize.Level1)
182 {
183     EXPECT_EQ(static_cast<int32_t>(Status::OK), buffer_->Destroy());
184     buffer_ = nullptr;
185 }
186 
187 #ifdef AVBUFFER_CAPI_UNIT_TEST
188 
189 /**
190  * @tc.name: AVBuffer_Capi_Create_001
191  * @tc.desc: create buffer with capacity > 0
192  * @tc.type: FUNC
193  */
194 HWTEST_F(AVBufferFrameworkUnitTest, AVBuffer_Capi_Create_001, TestSize.Level1)
195 {
196     auto buffer = OH_AVBuffer_Create(MEMSIZE);
197     ASSERT_NE(buffer, nullptr);
198     EXPECT_EQ(OH_AVBuffer_Destroy(buffer), AV_ERR_OK);
199 }
200 
201 /**
202  * @tc.name: AVBuffer_Capi_Create_002
203  * @tc.desc: create buffer with capacity = 0
204  * @tc.type: FUNC
205  */
206 HWTEST_F(AVBufferFrameworkUnitTest, AVBuffer_Capi_Create_002, TestSize.Level1)
207 {
208     auto buffer = OH_AVBuffer_Create(0);
209     ASSERT_EQ(buffer, nullptr);
210 }
211 
212 /**
213  * @tc.name: AVBuffer_Capi_Create_003
214  * @tc.desc: create buffer with capacity < 0
215  * @tc.type: FUNC
216  */
217 HWTEST_F(AVBufferFrameworkUnitTest, AVBuffer_Capi_Create_003, TestSize.Level1)
218 {
219     auto buffer = OH_AVBuffer_Create(-1);
220     ASSERT_EQ(buffer, nullptr);
221 }
222 
223 /**
224  * @tc.name: AVBuffer_Capi_Destroy_001
225  * @tc.desc: Destroy buffer with nullptr
226  * @tc.type: FUNC
227  */
228 HWTEST_F(AVBufferFrameworkUnitTest, AVBuffer_Capi_Destroy_001, TestSize.Level1)
229 {
230     EXPECT_EQ(OH_AVBuffer_Destroy(nullptr), AV_ERR_INVALID_VAL);
231 }
232 
233 /**
234  * @tc.name: AVBuffer_Capi_Destroy_002
235  * @tc.desc: Destroy buffer with not user created
236  * @tc.type: FUNC
237  */
238 HWTEST_F(AVBufferFrameworkUnitTest, AVBuffer_Capi_Destroy_002, TestSize.Level1)
239 {
240     auto buffer = OH_AVBuffer_Create(MEMSIZE);
241     ASSERT_NE(buffer, nullptr);
242     buffer->isUserCreated = false;
243     EXPECT_EQ(OH_AVBuffer_Destroy(buffer), AV_ERR_OPERATE_NOT_PERMIT);
244     delete buffer;
245 }
246 
247 /**
248  * @tc.name: AVBuffer_Capi_Destroy_003
249  * @tc.desc: Destroy buffer with error magic object
250  * @tc.type: FUNC
251  */
252 HWTEST_F(AVBufferFrameworkUnitTest, AVBuffer_Capi_Destroy_003, TestSize.Level1)
253 {
254     auto buffer = OH_AVBuffer_Create(MEMSIZE);
255     ASSERT_NE(buffer, nullptr);
256     buffer->magic_ = MFMagic::MFMAGIC_FORMAT;
257     EXPECT_EQ(OH_AVBuffer_Destroy(buffer), AV_ERR_INVALID_VAL);
258     delete buffer;
259 }
260 
261 /**
262  * @tc.name: AVBuffer_Capi_Create_And_Destroy_001
263  * @tc.desc: Repeatedly creating and destroying buffers
264  * @tc.type: FUNC
265  */
266 HWTEST_F(AVBufferFrameworkUnitTest, AVBuffer_Capi_Create_And_Destroy_001, TestSize.Level1)
267 {
268     for (int32_t i = 0; i < TEST_LOOP_DEPTH; ++i) {
269         auto buffer = OH_AVBuffer_Create(MEMSIZE);
270         ASSERT_NE(buffer, nullptr);
271         EXPECT_EQ(OH_AVBuffer_Destroy(buffer), AV_ERR_OK);
272     }
273 }
274 
275 /**
276  * @tc.name: AVBuffer_Capi_SetAndGetBufferAttr_001
277  * @tc.desc: Set buffer attr with memory is not nullptr
278  * @tc.type: FUNC
279  */
280 HWTEST_F(AVBufferFrameworkUnitTest, AVBuffer_Capi_SetAndGetBufferAttr_001, TestSize.Level1)
281 {
282     auto buffer = OH_AVBuffer_Create(MEMSIZE);
283     ASSERT_NE(buffer, nullptr);
284     OH_AVCodecBufferAttr attr;
285     attr.size = MEMSIZE;
286     attr.offset = DEFAULT_OFFSET;
287     attr.pts = DEFAULT_PTS;
288     attr.flags = DEFAULT_FLAG;
289     EXPECT_EQ(OH_AVBuffer_SetBufferAttr(buffer, &attr), AV_ERR_OK);
290 
291     OH_AVCodecBufferAttr getAttr;
292     EXPECT_EQ(AV_ERR_OK, OH_AVBuffer_GetBufferAttr(buffer, &getAttr));
293     EXPECT_EQ(getAttr.size, MEMSIZE);
294     EXPECT_EQ(getAttr.offset, DEFAULT_OFFSET);
295     EXPECT_EQ(getAttr.pts, DEFAULT_PTS);
296     EXPECT_EQ(getAttr.flags, DEFAULT_FLAG);
297 }
298 
299 /**
300  * @tc.name: AVBuffer_Capi_SetAndGetBufferAttr_002
301  * @tc.desc: Set buffer attr with memory is nullptr
302  * @tc.type: FUNC
303  */
304 HWTEST_F(AVBufferFrameworkUnitTest, AVBuffer_Capi_SetAndGetBufferAttr_002, TestSize.Level1)
305 {
306     auto buffer = OH_AVBuffer_Create(MEMSIZE);
307     ASSERT_NE(buffer, nullptr);
308     OH_AVCodecBufferAttr attr;
309     attr.size = MEMSIZE;
310     attr.offset = DEFAULT_OFFSET;
311     attr.pts = DEFAULT_PTS;
312     attr.flags = DEFAULT_FLAG;
313     buffer->buffer_->memory_ = nullptr;
314     EXPECT_EQ(OH_AVBuffer_SetBufferAttr(buffer, &attr), AV_ERR_OK);
315 
316     OH_AVCodecBufferAttr getAttr;
317     EXPECT_EQ(AV_ERR_OK, OH_AVBuffer_GetBufferAttr(buffer, &getAttr));
318     EXPECT_EQ(getAttr.size, 0);
319     EXPECT_EQ(getAttr.offset, 0);
320     EXPECT_EQ(getAttr.pts, DEFAULT_PTS);
321     EXPECT_EQ(getAttr.flags, DEFAULT_FLAG);
322 }
323 
324 /**
325  * @tc.name: AVBuffer_Capi_SetAndGetBufferAttr_003
326  * @tc.desc: Repeatedly setting and getting buffer attr
327  * @tc.type: FUNC
328  */
329 HWTEST_F(AVBufferFrameworkUnitTest, AVBuffer_Capi_SetAndGetBufferAttr_003, TestSize.Level1)
330 {
331     auto buffer = OH_AVBuffer_Create(MEMSIZE);
332     ASSERT_NE(buffer, nullptr);
333     for (int32_t i = 0; i < TEST_LOOP_DEPTH; ++i) {
334         OH_AVCodecBufferAttr attr;
335         attr.size = MEMSIZE;
336         attr.offset = DEFAULT_OFFSET;
337         attr.pts = DEFAULT_PTS;
338         attr.flags = DEFAULT_FLAG;
339         EXPECT_EQ(OH_AVBuffer_SetBufferAttr(buffer, &attr), AV_ERR_OK);
340 
341         OH_AVCodecBufferAttr getAttr;
342         EXPECT_EQ(AV_ERR_OK, OH_AVBuffer_GetBufferAttr(buffer, &getAttr));
343         EXPECT_EQ(getAttr.size, MEMSIZE);
344         EXPECT_EQ(getAttr.offset, DEFAULT_OFFSET);
345         EXPECT_EQ(getAttr.pts, DEFAULT_PTS);
346         EXPECT_EQ(getAttr.flags, DEFAULT_FLAG);
347     }
348 }
349 
350 /**
351  * @tc.name: AVBuffer_Capi_GetBufferAttr_Invalid_001
352  * @tc.desc: Get buffer attr with attr is nullptr
353  * @tc.type: FUNC
354  */
355 HWTEST_F(AVBufferFrameworkUnitTest, AVBuffer_Capi_GetBufferAttr_Invalid_001, TestSize.Level1)
356 {
357     auto buffer = OH_AVBuffer_Create(MEMSIZE);
358     ASSERT_NE(buffer, nullptr);
359     EXPECT_EQ(AV_ERR_INVALID_VAL, OH_AVBuffer_GetBufferAttr(buffer, nullptr));
360     EXPECT_EQ(OH_AVBuffer_Destroy(buffer), AV_ERR_OK);
361 }
362 
363 /**
364  * @tc.name: AVBuffer_Capi_GetBufferAttr_Invalid_002
365  * @tc.desc: Get buffer attr with buffer->buffer_ is nullptr
366  * @tc.type: FUNC
367  */
368 HWTEST_F(AVBufferFrameworkUnitTest, AVBuffer_Capi_GetBufferAttr_Invalid_002, TestSize.Level1)
369 {
370     auto buffer = OH_AVBuffer_Create(MEMSIZE);
371     ASSERT_NE(buffer, nullptr);
372     buffer->buffer_ = nullptr;
373     OH_AVCodecBufferAttr getAttr;
374     EXPECT_EQ(AV_ERR_INVALID_VAL, OH_AVBuffer_GetBufferAttr(buffer, &getAttr));
375     EXPECT_EQ(OH_AVBuffer_Destroy(buffer), AV_ERR_OK);
376 }
377 
378 /**
379  * @tc.name: AVBuffer_Capi_GetBufferAttr_Invalid_003
380  * @tc.desc: Get buffer attr with buffer is nullptr
381  * @tc.type: FUNC
382  */
383 HWTEST_F(AVBufferFrameworkUnitTest, AVBuffer_Capi_GetBufferAttr_Invalid_003, TestSize.Level1)
384 {
385     OH_AVCodecBufferAttr getAttr;
386     EXPECT_EQ(AV_ERR_INVALID_VAL, OH_AVBuffer_GetBufferAttr(nullptr, &getAttr));
387 }
388 
389 /**
390  * @tc.name: AVBuffer_Capi_GetBufferAttr_Invalid_004
391  * @tc.desc: Get buffer attr with buffer magic is error
392  * @tc.type: FUNC
393  */
394 HWTEST_F(AVBufferFrameworkUnitTest, AVBuffer_Capi_GetBufferAttr_Invalid_004, TestSize.Level1)
395 {
396     auto buffer = OH_AVBuffer_Create(MEMSIZE);
397     buffer->magic_ = MFMagic::MFMAGIC_FORMAT;
398     OH_AVCodecBufferAttr getAttr;
399     EXPECT_EQ(AV_ERR_INVALID_VAL, OH_AVBuffer_GetBufferAttr(buffer, &getAttr));
400     buffer->magic_ = MFMagic::MFMAGIC_AVBUFFER;
401     EXPECT_EQ(OH_AVBuffer_Destroy(buffer), AV_ERR_OK);
402 }
403 
404 /**
405  * @tc.name: AVBuffer_Capi_SetBufferAttr_Invalid_001
406  * @tc.desc: Set buffer attr with attr is nullptr
407  * @tc.type: FUNC
408  */
409 HWTEST_F(AVBufferFrameworkUnitTest, AVBuffer_Capi_SetBufferAttr_Invalid_001, TestSize.Level1)
410 {
411     auto buffer = OH_AVBuffer_Create(MEMSIZE);
412     ASSERT_NE(buffer, nullptr);
413     EXPECT_EQ(AV_ERR_INVALID_VAL, OH_AVBuffer_SetBufferAttr(buffer, nullptr));
414     EXPECT_EQ(OH_AVBuffer_Destroy(buffer), AV_ERR_OK);
415 }
416 
417 /**
418  * @tc.name: AVBuffer_Capi_SetBufferAttr_Invalid_002
419  * @tc.desc: Set buffer attr with buffer->buffer_ is nullptr
420  * @tc.type: FUNC
421  */
422 HWTEST_F(AVBufferFrameworkUnitTest, AVBuffer_Capi_SetBufferAttr_Invalid_002, TestSize.Level1)
423 {
424     auto buffer = OH_AVBuffer_Create(MEMSIZE);
425     ASSERT_NE(buffer, nullptr);
426     buffer->buffer_ = nullptr;
427     OH_AVCodecBufferAttr getAttr;
428     EXPECT_EQ(AV_ERR_INVALID_VAL, OH_AVBuffer_SetBufferAttr(buffer, &getAttr));
429     EXPECT_EQ(OH_AVBuffer_Destroy(buffer), AV_ERR_OK);
430 }
431 
432 /**
433  * @tc.name: AVBuffer_Capi_SetBufferAttr_Invalid_003
434  * @tc.desc: Set buffer attr with buffer is nullptr
435  * @tc.type: FUNC
436  */
437 HWTEST_F(AVBufferFrameworkUnitTest, AVBuffer_Capi_SetBufferAttr_Invalid_003, TestSize.Level1)
438 {
439     OH_AVCodecBufferAttr getAttr;
440     EXPECT_EQ(AV_ERR_INVALID_VAL, OH_AVBuffer_SetBufferAttr(nullptr, &getAttr));
441 }
442 
443 /**
444  * @tc.name: AVBuffer_Capi_SetBufferAttr_Invalid_004
445  * @tc.desc: Set buffer attr with buffer magic is error
446  * @tc.type: FUNC
447  */
448 HWTEST_F(AVBufferFrameworkUnitTest, AVBuffer_Capi_SetBufferAttr_Invalid_004, TestSize.Level1)
449 {
450     auto buffer = OH_AVBuffer_Create(MEMSIZE);
451     buffer->magic_ = MFMagic::MFMAGIC_FORMAT;
452     OH_AVCodecBufferAttr getAttr;
453     EXPECT_EQ(AV_ERR_INVALID_VAL, OH_AVBuffer_SetBufferAttr(buffer, &getAttr));
454     buffer->magic_ = MFMagic::MFMAGIC_AVBUFFER;
455     EXPECT_EQ(OH_AVBuffer_Destroy(buffer), AV_ERR_OK);
456 }
457 
458 /**
459  * @tc.name: AVBuffer_Capi_SetBufferAttr_Invalid_005
460  * @tc.desc: Set buffer attr with size is out of range 1
461  * @tc.type: FUNC
462  */
463 HWTEST_F(AVBufferFrameworkUnitTest, AVBuffer_Capi_SetBufferAttr_Invalid_005, TestSize.Level1)
464 {
465     auto buffer = OH_AVBuffer_Create(MEMSIZE);
466     OH_AVCodecBufferAttr getAttr;
467     getAttr.size = MEMSIZE + 1;
468     EXPECT_EQ(AV_ERR_INVALID_VAL, OH_AVBuffer_SetBufferAttr(buffer, &getAttr));
469     EXPECT_EQ(OH_AVBuffer_Destroy(buffer), AV_ERR_OK);
470 }
471 
472 /**
473  * @tc.name: AVBuffer_Capi_SetBufferAttr_Invalid_006
474  * @tc.desc: Set buffer attr with size is out of range 2
475  * @tc.type: FUNC
476  */
477 HWTEST_F(AVBufferFrameworkUnitTest, AVBuffer_Capi_SetBufferAttr_Invalid_006, TestSize.Level1)
478 {
479     auto buffer = OH_AVBuffer_Create(MEMSIZE);
480     OH_AVCodecBufferAttr getAttr;
481     getAttr.size = -1;
482     EXPECT_EQ(AV_ERR_INVALID_VAL, OH_AVBuffer_SetBufferAttr(buffer, &getAttr));
483     EXPECT_EQ(OH_AVBuffer_Destroy(buffer), AV_ERR_OK);
484 }
485 
486 /**
487  * @tc.name: AVBuffer_Capi_SetBufferAttr_Invalid_007
488  * @tc.desc: Set buffer attr with offset is out of range 1
489  * @tc.type: FUNC
490  */
491 HWTEST_F(AVBufferFrameworkUnitTest, AVBuffer_Capi_SetBufferAttr_Invalid_007, TestSize.Level1)
492 {
493     auto buffer = OH_AVBuffer_Create(MEMSIZE);
494     OH_AVCodecBufferAttr getAttr;
495     getAttr.offset = MEMSIZE + 1;
496     EXPECT_EQ(AV_ERR_INVALID_VAL, OH_AVBuffer_SetBufferAttr(buffer, &getAttr));
497     EXPECT_EQ(OH_AVBuffer_Destroy(buffer), AV_ERR_OK);
498 }
499 
500 /**
501  * @tc.name: AVBuffer_Capi_SetBufferAttr_Invalid_008
502  * @tc.desc: Set buffer attr with offset is out of range 2
503  * @tc.type: FUNC
504  */
505 HWTEST_F(AVBufferFrameworkUnitTest, AVBuffer_Capi_SetBufferAttr_Invalid_008, TestSize.Level1)
506 {
507     auto buffer = OH_AVBuffer_Create(MEMSIZE);
508     OH_AVCodecBufferAttr getAttr;
509     getAttr.offset = -1;
510     EXPECT_EQ(AV_ERR_INVALID_VAL, OH_AVBuffer_SetBufferAttr(buffer, &getAttr));
511     EXPECT_EQ(OH_AVBuffer_Destroy(buffer), AV_ERR_OK);
512 }
513 
514 /**
515  * @tc.name: AVBuffer_Capi_SetAndGetParameter_001
516  * @tc.desc: Set buffer parameter
517  * @tc.type: FUNC
518  */
519 HWTEST_F(AVBufferFrameworkUnitTest, AVBuffer_Capi_SetAndGetParameter_001, TestSize.Level1)
520 {
521     auto buffer = OH_AVBuffer_Create(MEMSIZE);
522     ASSERT_NE(buffer, nullptr);
523     auto format = OH_AVFormat_Create();
524     ASSERT_NE(format, nullptr);
525     EXPECT_TRUE(OH_AVFormat_SetIntValue(format, INT_CAPI_TESTKEY.data(), INTVALUE));
526     EXPECT_TRUE(OH_AVFormat_SetLongValue(format, LONG_CAPI_TESTKEY.data(), LONGVALUE));
527     EXPECT_TRUE(OH_AVFormat_SetFloatValue(format, FlOAT_CAPI_TESTKEY.data(), FLOATVALUE));
528     EXPECT_TRUE(OH_AVFormat_SetDoubleValue(format, DOUBLE_CAPI_TESTKEY.data(), DOUBLEVALUE));
529     EXPECT_TRUE(OH_AVFormat_SetStringValue(format, STRING_CAPI_TESTKEY.data(), STRINGVALUE.c_str()));
530 
531     EXPECT_EQ(OH_AVBuffer_SetParameter(buffer, format), AV_ERR_OK);
532 
533     int32_t getIntValue = 0;
534     int64_t getLongValue = 0;
535     float getFloatValue = 0.0;
536     double getDoubleValue = 0.0;
537     const char *getStringValue = nullptr;
538 
539     auto getFormat = OH_AVBuffer_GetParameter(buffer);
540     ASSERT_NE(getFormat, nullptr);
541     EXPECT_TRUE(OH_AVFormat_GetIntValue(getFormat, INT_CAPI_TESTKEY.data(), &getIntValue));
542     EXPECT_TRUE(OH_AVFormat_GetLongValue(getFormat, LONG_CAPI_TESTKEY.data(), &getLongValue));
543     EXPECT_TRUE(OH_AVFormat_GetFloatValue(getFormat, FlOAT_CAPI_TESTKEY.data(), &getFloatValue));
544     EXPECT_TRUE(OH_AVFormat_GetDoubleValue(getFormat, DOUBLE_CAPI_TESTKEY.data(), &getDoubleValue));
545     EXPECT_TRUE(OH_AVFormat_GetStringValue(getFormat, STRING_CAPI_TESTKEY.data(), &getStringValue));
546 
547     EXPECT_EQ(INTVALUE, getIntValue);
548     EXPECT_EQ(LONGVALUE, getLongValue);
549     EXPECT_EQ(FLOATVALUE, getFloatValue);
550     EXPECT_EQ(DOUBLEVALUE, getDoubleValue);
551     EXPECT_EQ(STRINGVALUE, std::string(getStringValue));
552     OH_AVFormat_Destroy(format);
553     OH_AVFormat_Destroy(getFormat);
554     EXPECT_EQ(OH_AVBuffer_Destroy(buffer), AV_ERR_OK);
555 }
556 
557 /**
558  * @tc.name: AVBuffer_Capi_SetAndGetParameter_002
559  * @tc.desc: Get buffer parameter 3 times
560  * @tc.type: FUNC
561  */
562 HWTEST_F(AVBufferFrameworkUnitTest, AVBuffer_Capi_SetAndGetParameter_002, TestSize.Level1)
563 {
564     auto buffer = OH_AVBuffer_Create(MEMSIZE);
565     ASSERT_NE(buffer, nullptr);
566     auto format = OH_AVFormat_Create();
567     ASSERT_NE(format, nullptr);
568     EXPECT_TRUE(OH_AVFormat_SetIntValue(format, INT_CAPI_TESTKEY.data(), INTVALUE));
569     EXPECT_EQ(OH_AVBuffer_SetParameter(buffer, format), AV_ERR_OK);
570 
571     int32_t getIntValue = 0;
572     auto getFormat = OH_AVBuffer_GetParameter(buffer);
573     OH_AVFormat_Destroy(getFormat);
574     getFormat = OH_AVBuffer_GetParameter(buffer);
575     OH_AVFormat_Destroy(getFormat);
576     getFormat = OH_AVBuffer_GetParameter(buffer);
577 
578     ASSERT_NE(getFormat, nullptr);
579     EXPECT_TRUE(OH_AVFormat_GetIntValue(getFormat, INT_CAPI_TESTKEY.data(), &getIntValue));
580     EXPECT_EQ(INTVALUE, getIntValue);
581     OH_AVFormat_Destroy(format);
582     OH_AVFormat_Destroy(getFormat);
583     EXPECT_EQ(OH_AVBuffer_Destroy(buffer), AV_ERR_OK);
584 }
585 
586 /**
587  * @tc.name: AVBuffer_Capi_SetParameter_Invalid_001
588  * @tc.desc: Set buffer parameter with buffer is nullptr
589  * @tc.type: FUNC
590  */
591 HWTEST_F(AVBufferFrameworkUnitTest, AVBuffer_Capi_SetParameter_Invalid_001, TestSize.Level1)
592 {
593     auto format = OH_AVFormat_Create();
594     ASSERT_NE(format, nullptr);
595     EXPECT_EQ(AV_ERR_INVALID_VAL, OH_AVBuffer_SetParameter(nullptr, format));
596     OH_AVFormat_Destroy(format);
597 }
598 
599 /**
600  * @tc.name: AVBuffer_Capi_SetParameter_Invalid_002
601  * @tc.desc: Set buffer parameter with format is nullptr
602  * @tc.type: FUNC
603  */
604 HWTEST_F(AVBufferFrameworkUnitTest, AVBuffer_Capi_SetParameter_Invalid_002, TestSize.Level1)
605 {
606     auto buffer = OH_AVBuffer_Create(MEMSIZE);
607     ASSERT_NE(buffer, nullptr);
608     EXPECT_EQ(AV_ERR_INVALID_VAL, OH_AVBuffer_SetParameter(buffer, nullptr));
609     EXPECT_EQ(OH_AVBuffer_Destroy(buffer), AV_ERR_OK);
610 }
611 
612 /**
613  * @tc.name: AVBuffer_Capi_GetParameter_Invalid_001
614  * @tc.desc: Get buffer parameter with buffer is nullptr
615  * @tc.type: FUNC
616  */
617 HWTEST_F(AVBufferFrameworkUnitTest, AVBuffer_Capi_GetParameter_Invalid_001, TestSize.Level1)
618 {
619     EXPECT_EQ(nullptr, OH_AVBuffer_GetParameter(nullptr));
620 }
621 
622 /**
623  * @tc.name: AVBuffer_Capi_GetAddr_Invalid_001
624  * @tc.desc: Get buffer address with buffer is nullptr
625  * @tc.type: FUNC
626  */
627 HWTEST_F(AVBufferFrameworkUnitTest, AVBuffer_Capi_GetAddr_Invalid_001, TestSize.Level1)
628 {
629     EXPECT_EQ(nullptr, OH_AVBuffer_GetAddr(nullptr));
630 }
631 
632 /**
633  * @tc.name: AVBuffer_Capi_GetAddr_Invalid_002
634  * @tc.desc: Get buffer address with buffer magic is error
635  * @tc.type: FUNC
636  */
637 HWTEST_F(AVBufferFrameworkUnitTest, AVBuffer_Capi_GetAddr_Invalid_002, TestSize.Level1)
638 {
639     auto buffer = OH_AVBuffer_Create(MEMSIZE);
640     buffer->magic_ = MFMagic::MFMAGIC_FORMAT;
641     EXPECT_EQ(nullptr, OH_AVBuffer_GetAddr(buffer));
642     buffer->magic_ = MFMagic::MFMAGIC_AVBUFFER;
643     EXPECT_EQ(OH_AVBuffer_Destroy(buffer), AV_ERR_OK);
644 }
645 
646 /**
647  * @tc.name: AVBuffer_Capi_GetAddr_Invalid_003
648  * @tc.desc: Get buffer address with buffer->buffer_ is nullptr
649  * @tc.type: FUNC
650  */
651 HWTEST_F(AVBufferFrameworkUnitTest, AVBuffer_Capi_GetAddr_Invalid_003, TestSize.Level1)
652 {
653     auto buffer = OH_AVBuffer_Create(MEMSIZE);
654     buffer->buffer_ = nullptr;
655     EXPECT_EQ(nullptr, OH_AVBuffer_GetAddr(buffer));
656     EXPECT_EQ(OH_AVBuffer_Destroy(buffer), AV_ERR_OK);
657 }
658 
659 /**
660  * @tc.name: AVBuffer_Capi_GetAddr_Invalid_004
661  * @tc.desc: Get buffer address with buffer->buffer_->memory_ is nullptr
662  * @tc.type: FUNC
663  */
664 HWTEST_F(AVBufferFrameworkUnitTest, AVBuffer_Capi_GetAddr_Invalid_004, TestSize.Level1)
665 {
666     auto buffer = OH_AVBuffer_Create(MEMSIZE);
667     buffer->buffer_->memory_ = nullptr;
668     EXPECT_EQ(nullptr, OH_AVBuffer_GetAddr(buffer));
669     EXPECT_EQ(OH_AVBuffer_Destroy(buffer), AV_ERR_OK);
670 }
671 
672 /**
673  * @tc.name: AVBuffer_Capi_GetCapacity_Invalid_001
674  * @tc.desc: Get buffer address with buffer is nullptr
675  * @tc.type: FUNC
676  */
677 HWTEST_F(AVBufferFrameworkUnitTest, AVBuffer_Capi_GetCapacity_Invalid_001, TestSize.Level1)
678 {
679     EXPECT_EQ(-1, OH_AVBuffer_GetCapacity(nullptr));
680 }
681 
682 /**
683  * @tc.name: AVBuffer_Capi_GetCapacity_Invalid_002
684  * @tc.desc: Get buffer address with buffer magic is error
685  * @tc.type: FUNC
686  */
687 HWTEST_F(AVBufferFrameworkUnitTest, AVBuffer_Capi_GetCapacity_Invalid_002, TestSize.Level1)
688 {
689     auto buffer = OH_AVBuffer_Create(MEMSIZE);
690     buffer->magic_ = MFMagic::MFMAGIC_FORMAT;
691     EXPECT_EQ(-1, OH_AVBuffer_GetCapacity(buffer));
692     buffer->magic_ = MFMagic::MFMAGIC_AVBUFFER;
693     EXPECT_EQ(OH_AVBuffer_Destroy(buffer), AV_ERR_OK);
694 }
695 
696 /**
697  * @tc.name: AVBuffer_Capi_GetCapacity_Invalid_003
698  * @tc.desc: Get buffer address with buffer->buffer_ is nullptr
699  * @tc.type: FUNC
700  */
701 HWTEST_F(AVBufferFrameworkUnitTest, AVBuffer_Capi_GetCapacity_Invalid_003, TestSize.Level1)
702 {
703     auto buffer = OH_AVBuffer_Create(MEMSIZE);
704     buffer->buffer_ = nullptr;
705     EXPECT_EQ(-1, OH_AVBuffer_GetCapacity(buffer));
706     EXPECT_EQ(OH_AVBuffer_Destroy(buffer), AV_ERR_OK);
707 }
708 
709 /**
710  * @tc.name: AVBuffer_Capi_GetCapacity_Invalid_004
711  * @tc.desc: Get buffer address with buffer->buffer_->memory_ is nullptr
712  * @tc.type: FUNC
713  */
714 HWTEST_F(AVBufferFrameworkUnitTest, AVBuffer_Capi_GetCapacity_Invalid_004, TestSize.Level1)
715 {
716     auto buffer = OH_AVBuffer_Create(MEMSIZE);
717     buffer->buffer_->memory_ = nullptr;
718     EXPECT_EQ(-1, OH_AVBuffer_GetCapacity(buffer));
719     EXPECT_EQ(OH_AVBuffer_Destroy(buffer), AV_ERR_OK);
720 }
721 
722 /**
723  * @tc.name: AVBuffer_Capi_GetNativeBuffer_001
724  * @tc.desc: get native buffer
725  * @tc.type: FUNC
726  */
727 HWTEST_F(AVBufferFrameworkUnitTest, AVBuffer_Capi_GetNativeBuffer_001, TestSize.Level1)
728 {
729     auto allocator = AVAllocatorFactory::CreateSurfaceAllocator(DEFAULT_CONFIG);
730     ASSERT_NE(nullptr, allocator);
731     auto surfaceAVBuffer = AVBuffer::CreateAVBuffer(allocator, 0, 0);
732     ASSERT_NE(nullptr, surfaceAVBuffer);
733     ASSERT_NE(nullptr, surfaceAVBuffer->memory_->GetAddr());
734 
735     struct OH_AVBuffer *buf = new (std::nothrow) OH_AVBuffer(surfaceAVBuffer);
736     auto nativeBuffer = OH_AVBuffer_GetNativeBuffer(buf);
737     EXPECT_NE(nullptr, nativeBuffer);
738     EXPECT_EQ(0, OH_NativeBuffer_Unreference(nativeBuffer));
739     delete buf;
740 }
741 
742 /**
743  * @tc.name: AVBuffer_Capi_GetNativeBuffer_002
744  * @tc.desc: get native buffer repeat
745  * @tc.type: FUNC
746  */
747 HWTEST_F(AVBufferFrameworkUnitTest, AVBuffer_Capi_GetNativeBuffer_002, TestSize.Level1)
748 {
749     auto allocator = AVAllocatorFactory::CreateSurfaceAllocator(DEFAULT_CONFIG);
750     ASSERT_NE(nullptr, allocator);
751     auto surfaceAVBuffer = AVBuffer::CreateAVBuffer(allocator, 0, 0);
752     ASSERT_NE(nullptr, surfaceAVBuffer);
753     ASSERT_NE(nullptr, surfaceAVBuffer->memory_->GetAddr());
754 
755     struct OH_AVBuffer *buf = new (std::nothrow) OH_AVBuffer(surfaceAVBuffer);
756     for (int32_t i = 0; i < TEST_LOOP_DEPTH; ++i) {
757         auto nativeBuffer = OH_AVBuffer_GetNativeBuffer(buf);
758         EXPECT_NE(nullptr, nativeBuffer);
759         EXPECT_EQ(0, OH_NativeBuffer_Unreference(nativeBuffer));
760     }
761     delete buf;
762 }
763 #endif
764 } // namespace AVBufferUT
765 } // namespace Media
766 } // namespace OHOS