1 /*
2 * Copyright (C) 2024 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 <gtest/gtest.h>
17 #include "status.h"
18 #include "buffer/avbuffer_queue.h"
19 #include "avbuffer_queue_impl.h"
20
21 using namespace std;
22 using namespace testing::ext;
23 using namespace OHOS::Media;
24
25 namespace OHOS {
26 namespace Media {
27 namespace AVBufferQueueFuncUT {
28 class AVBufferQueueInnerUnitTest : public testing::Test {
29 public:
30 static void SetUpTestCase(void);
31
32 static void TearDownTestCase(void);
33
34 void SetUp(void);
35
36 void TearDown(void);
37
38 std::shared_ptr<AVBufferQueueImpl> avBufferQueueImpl_;
39 };
40
41 class BrokerListener : public IBrokerListener {
42 public:
BrokerListener()43 explicit BrokerListener() {}
44
AsObject()45 sptr<IRemoteObject> AsObject() override
46 {
47 return nullptr;
48 }
49
OnBufferFilled(std::shared_ptr<AVBuffer> & avBuffer)50 void OnBufferFilled(std::shared_ptr<AVBuffer> &avBuffer) override
51 {
52 ASSERT_NE(avBuffer, nullptr);
53 }
54 };
55
56 class ConsumerListener : public IConsumerListener {
57 public:
ConsumerListener()58 explicit ConsumerListener() {}
59
OnBufferAvailable()60 void OnBufferAvailable() override {}
61 };
62
SetUpTestCase(void)63 void AVBufferQueueInnerUnitTest::SetUpTestCase(void) {}
64
TearDownTestCase(void)65 void AVBufferQueueInnerUnitTest::TearDownTestCase(void) {}
66
SetUp(void)67 void AVBufferQueueInnerUnitTest::SetUp(void)
68 {
69 std::string name = "queue";
70 avBufferQueueImpl_ = std::make_shared<AVBufferQueueImpl>(name);
71 }
72
TearDown(void)73 void AVBufferQueueInnerUnitTest::TearDown(void)
74 {
75 avBufferQueueImpl_ = nullptr;
76 }
77
78 /**
79 * @tc.name: GetLocalProducerTest
80 * @tc.desc: Test get local producer
81 * @tc.type: FUNC
82 */
83 HWTEST_F(AVBufferQueueInnerUnitTest, GetLocalProducerTest, TestSize.Level1)
84 {
85 auto producer1 = avBufferQueueImpl_->GetLocalProducer();
86 ASSERT_NE(producer1, nullptr);
87
88 auto producer2 = avBufferQueueImpl_->GetLocalProducer();
89 ASSERT_EQ(producer1, producer2);
90 }
91
92 /**
93 * @tc.name: GetLocalConsumerTest
94 * @tc.desc: Test get local consumer
95 * @tc.type: FUNC
96 */
97 HWTEST_F(AVBufferQueueInnerUnitTest, GetLocalConsumerTest, TestSize.Level1)
98 {
99 auto consumer1 = avBufferQueueImpl_->GetLocalConsumer();
100 ASSERT_NE(consumer1, nullptr);
101
102 auto consumer2 = avBufferQueueImpl_->GetLocalConsumer();
103 ASSERT_EQ(consumer1, consumer2);
104 }
105
106 /**
107 * @tc.name: SetQueueSizeTest
108 * @tc.desc: Test set queue size
109 * @tc.type: FUNC
110 */
111 HWTEST_F(AVBufferQueueInnerUnitTest, SetQueueSizeTest, TestSize.Level1)
112 {
113 uint32_t size = 10;
114 ASSERT_EQ(avBufferQueueImpl_->SetQueueSize(size), Status::OK);
115 ASSERT_EQ(avBufferQueueImpl_->GetQueueSize(), size);
116
117 size = AVBUFFER_QUEUE_MAX_QUEUE_SIZE;
118 ASSERT_EQ(avBufferQueueImpl_->SetQueueSize(size), Status::OK);
119 ASSERT_EQ(avBufferQueueImpl_->GetQueueSize(), size);
120
121 ASSERT_EQ(avBufferQueueImpl_->SetQueueSize(size + 1), Status::ERROR_INVALID_BUFFER_SIZE);
122
123 size = 0;
124 ASSERT_EQ(avBufferQueueImpl_->SetQueueSize(size), Status::OK);
125 ASSERT_EQ(avBufferQueueImpl_->GetQueueSize(), size);
126 }
127
128 /**
129 * @tc.name: SetLargerQueueSize
130 * @tc.desc: Test set Larger queue size
131 * @tc.type: FUNC
132 */
133 HWTEST_F(AVBufferQueueInnerUnitTest, SetLargerQueueSize, TestSize.Level1)
134 {
135 uint32_t size = AVBUFFER_QUEUE_MAX_QUEUE_SIZE + 1;
136 ASSERT_EQ(avBufferQueueImpl_->SetLargerQueueSize(size), Status::OK);
137 ASSERT_EQ(avBufferQueueImpl_->GetQueueSize(), size);
138
139 size = AVBUFFER_QUEUE_MAX_QUEUE_SIZE_FOR_LARGER;
140 ASSERT_EQ(avBufferQueueImpl_->SetLargerQueueSize(size), Status::OK);
141 ASSERT_EQ(avBufferQueueImpl_->GetQueueSize(), size);
142
143 ASSERT_EQ(avBufferQueueImpl_->SetLargerQueueSize(size + 1), Status::ERROR_INVALID_BUFFER_SIZE);
144
145 size = 0;
146 ASSERT_EQ(avBufferQueueImpl_->SetLargerQueueSize(size), Status::OK);
147 ASSERT_EQ(avBufferQueueImpl_->GetQueueSize(), size);
148 }
149
150 /**
151 * @tc.name: DeleteBuffersTest
152 * @tc.desc: Test delete buffers
153 * @tc.type: FUNC
154 */
155 HWTEST_F(AVBufferQueueInnerUnitTest, DeleteBuffersTest, TestSize.Level1)
156 {
157 sptr<IConsumerListener> listener = new ConsumerListener();
158 AVBufferConfig config;
159 config.size = 10;
160 config.memoryType = MemoryType::VIRTUAL_MEMORY;
161 avBufferQueueImpl_->SetConsumerListener(listener);
162 std::shared_ptr<AVBuffer> buffer1 = AVBuffer::CreateAVBuffer(config);
163 EXPECT_EQ(avBufferQueueImpl_->AllocBuffer(buffer1, config), Status::OK);
164 buffer1->memory_->SetSize(config.size);
165 EXPECT_EQ(avBufferQueueImpl_->RequestReuseBuffer(buffer1, config), Status::OK);
166 EXPECT_EQ(avBufferQueueImpl_->PushBuffer(buffer1, true), Status::OK);
167 config.capacity = 20;
168 std::shared_ptr<AVBuffer> buffer2 = AVBuffer::CreateAVBuffer(config);
169 EXPECT_EQ(avBufferQueueImpl_->AllocBuffer(buffer2, config), Status::OK);
170 buffer2->memory_->SetSize(config.size);
171 EXPECT_EQ(avBufferQueueImpl_->RequestReuseBuffer(buffer2, config), Status::OK);
172 EXPECT_EQ(avBufferQueueImpl_->PushBuffer(buffer2, true), Status::OK);
173
174 uint32_t count = 10;
175 avBufferQueueImpl_->InsertFreeBufferInOrder(buffer1->GetUniqueId());
176 avBufferQueueImpl_->InsertFreeBufferInOrder(buffer2->GetUniqueId());
177 avBufferQueueImpl_->DeleteBuffers(count);
178 ASSERT_EQ(avBufferQueueImpl_->GetQueueSize(), 0);
179
180 count = 0;
181 avBufferQueueImpl_->DeleteBuffers(count);
182 ASSERT_EQ(avBufferQueueImpl_->GetQueueSize(), 0);
183 }
184
185 /**
186 * @tc.name: ChceckConfigTest
187 * @tc.desc: Test check config
188 * @tc.type: FUNC
189 */
190 HWTEST_F(AVBufferQueueInnerUnitTest, ChceckConfigTest, TestSize.Level1)
191 {
192 AVBufferConfig config;
193 int32_t size = 10;
194
195 // memoryType : UNKNOWN_MEMORY
196 config.memoryType = MemoryType::UNKNOWN_MEMORY;
197 EXPECT_EQ(avBufferQueueImpl_->CheckConfig(config), Status::ERROR_UNEXPECTED_MEMORY_TYPE);
198
199 // memoryType_ : UNKNOWN_MEMORY, memoryType : !UNKNOWN_MEMORY
200 config.memoryType = MemoryType::SHARED_MEMORY;
201 avBufferQueueImpl_ = std::make_shared<AVBufferQueueImpl>(size, MemoryType::UNKNOWN_MEMORY, "test");
202 EXPECT_EQ(avBufferQueueImpl_->CheckConfig(config), Status::OK);
203
204 // memoryType_ : !UNKNOWN_MEMORY, memoryType : != memoryType_
205 config.memoryType = MemoryType::VIRTUAL_MEMORY;
206 avBufferQueueImpl_ = std::make_shared<AVBufferQueueImpl>(size, MemoryType::SHARED_MEMORY, "test");
207 EXPECT_EQ(avBufferQueueImpl_->CheckConfig(config), Status::ERROR_UNEXPECTED_MEMORY_TYPE);
208
209 // memoryType_ : !UNKNOWN_MEMORY, memoryType : == memoryType_
210 config.memoryType = MemoryType::SHARED_MEMORY;
211 avBufferQueueImpl_ = std::make_shared<AVBufferQueueImpl>(size, MemoryType::SHARED_MEMORY, "test");
212 EXPECT_EQ(avBufferQueueImpl_->CheckConfig(config), Status::OK);
213 }
214
215 /**
216 * @tc.name: PushBufferTest_001
217 * @tc.desc: Test push buffer interface
218 * @tc.type: FUNC
219 */
220 HWTEST_F(AVBufferQueueInnerUnitTest, PushBufferTest_001, TestSize.Level1)
221 {
222 AVBufferConfig config;
223 config.size = 100;
224 config.memoryType = MemoryType::VIRTUAL_MEMORY;
225 std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer(config);
226 EXPECT_EQ(avBufferQueueImpl_->AllocBuffer(buffer, config), Status::OK);
227
228 EXPECT_EQ(avBufferQueueImpl_->RequestReuseBuffer(buffer, config), Status::OK);
229 EXPECT_EQ(avBufferQueueImpl_->PushBuffer(buffer, true), Status::ERROR_INVALID_BUFFER_SIZE);
230 }
231
232 /**
233 * @tc.name: PushBufferTest_002
234 * @tc.desc: Test push buffer interface
235 * @tc.type: FUNC
236 */
237 HWTEST_F(AVBufferQueueInnerUnitTest, PushBufferTest_002, TestSize.Level1)
238 {
239 AVBufferConfig config;
240 config.size = 100;
241 config.memoryType = MemoryType::VIRTUAL_MEMORY;
242 std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer(config);
243 EXPECT_EQ(avBufferQueueImpl_->AllocBuffer(buffer, config), Status::OK);
244
245 EXPECT_EQ(avBufferQueueImpl_->PushBuffer(buffer, true), Status::ERROR_INVALID_BUFFER_STATE);
246 }
247
248 /**
249 * @tc.name: PushBufferTest_003
250 * @tc.desc: Test push buffer interface
251 * @tc.type: FUNC
252 */
253 HWTEST_F(AVBufferQueueInnerUnitTest, PushBufferTest_003, TestSize.Level1)
254 {
255 AVBufferConfig config;
256 config.size = -1;
257 config.capacity = 0;
258 config.memoryType = MemoryType::VIRTUAL_MEMORY;
259 std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer(config);
260 ASSERT_NE(nullptr, buffer);
261 EXPECT_EQ(avBufferQueueImpl_->AllocBuffer(buffer, config), Status::OK);
262 EXPECT_EQ(avBufferQueueImpl_->RequestReuseBuffer(buffer, config), Status::OK);
263 EXPECT_EQ(avBufferQueueImpl_->PushBuffer(buffer, true), Status::ERROR_INVALID_BUFFER_SIZE);
264 }
265
266 /**
267 * @tc.name: PushBufferTest_004
268 * @tc.desc: Test push buffer interface
269 * @tc.type: FUNC
270 */
271 HWTEST_F(AVBufferQueueInnerUnitTest, PushBufferTest_004, TestSize.Level1)
272 {
273 AVBufferConfig config;
274 config.size = 1;
275 config.capacity = 1;
276 config.memoryType = MemoryType::VIRTUAL_MEMORY;
277 std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer(config);
278 ASSERT_NE(nullptr, buffer);
279 EXPECT_EQ(avBufferQueueImpl_->AllocBuffer(buffer, config), Status::OK);
280 avBufferQueueImpl_->DeleteBuffers(1);
281 EXPECT_EQ(avBufferQueueImpl_->PushBuffer(buffer, true), Status::OK);
282 }
283
284 /**
285 * @tc.name: PushBufferTest_005
286 * @tc.desc: Test push buffer interface
287 * @tc.type: FUNC
288 */
289 HWTEST_F(AVBufferQueueInnerUnitTest, PushBufferTest_005, TestSize.Level1)
290 {
291 AVBufferConfig config;
292 config.size = 1;
293 config.capacity = 1;
294 config.memoryType = MemoryType::VIRTUAL_MEMORY;
295 std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer(config);
296 ASSERT_NE(nullptr, buffer);
297 EXPECT_EQ(avBufferQueueImpl_->AllocBuffer(buffer, config), Status::OK);
298 EXPECT_EQ(avBufferQueueImpl_->RequestReuseBuffer(buffer, config), Status::OK);
299 sptr<IBrokerListener> listener = new BrokerListener();
300 avBufferQueueImpl_->SetBrokerListener(listener);
301 EXPECT_EQ(avBufferQueueImpl_->PushBuffer(buffer, true), Status::OK);
302 }
303
304 /**
305 * @tc.name: PushBufferTest_006
306 * @tc.desc: Test push buffer interface
307 * @tc.type: FUNC
308 */
309 HWTEST_F(AVBufferQueueInnerUnitTest, PushBufferTest_006, TestSize.Level1)
310 {
311 AVBufferConfig config;
312 config.size = 1;
313 config.capacity = 1;
314 config.memoryType = MemoryType::VIRTUAL_MEMORY;
315 std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer(config);
316 ASSERT_NE(nullptr, buffer);
317 EXPECT_EQ(avBufferQueueImpl_->AllocBuffer(buffer, config), Status::OK);
318 EXPECT_EQ(avBufferQueueImpl_->RequestReuseBuffer(buffer, config), Status::OK);
319 sptr<IBrokerListener> listener = new BrokerListener();
320 avBufferQueueImpl_->SetBrokerListener(listener);
321 EXPECT_EQ(avBufferQueueImpl_->PushBuffer(buffer, false), Status::OK);
322 }
323
324 /**
325 * @tc.name: ReturnBufferTest
326 * @tc.desc: Test return buffer interface
327 * @tc.type: FUNC
328 */
329 HWTEST_F(AVBufferQueueInnerUnitTest, ReturnBufferTest, TestSize.Level1)
330 {
331 sptr<IConsumerListener> listener = new ConsumerListener();
332 AVBufferConfig config;
333 config.size = 1;
334 config.capacity = 1;
335 config.memoryType = MemoryType::VIRTUAL_MEMORY;
336 avBufferQueueImpl_->SetConsumerListener(listener);
337 std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer(config);
338 ASSERT_NE(nullptr, buffer);
339 EXPECT_EQ(avBufferQueueImpl_->AllocBuffer(buffer, config), Status::OK);
340 buffer->memory_->SetSize(config.size);
341 EXPECT_EQ(avBufferQueueImpl_->RequestReuseBuffer(buffer, config), Status::OK);
342 EXPECT_EQ(avBufferQueueImpl_->PushBuffer(buffer, true), Status::OK);
343 EXPECT_EQ(avBufferQueueImpl_->AcquireBuffer(buffer), Status::OK);
344
345 EXPECT_EQ(avBufferQueueImpl_->ReleaseBuffer(buffer->GetUniqueId()), Status::OK);
346 EXPECT_EQ(avBufferQueueImpl_->ReturnBuffer(buffer, false), Status::ERROR_INVALID_BUFFER_STATE);
347
348 buffer = AVBuffer::CreateAVBuffer(config);
349 EXPECT_EQ(avBufferQueueImpl_->AllocBuffer(buffer, config), Status::OK);
350 buffer->memory_->SetSize(config.size);
351 EXPECT_EQ(avBufferQueueImpl_->RequestReuseBuffer(buffer, config), Status::OK);
352 EXPECT_EQ(avBufferQueueImpl_->PushBuffer(buffer, true), Status::OK);
353 EXPECT_EQ(avBufferQueueImpl_->ReturnBuffer(buffer, true), Status::ERROR_INVALID_BUFFER_STATE);
354
355 EXPECT_EQ(avBufferQueueImpl_->ReturnBuffer(2, true), Status::ERROR_INVALID_BUFFER_ID);
356
357 buffer = AVBuffer::CreateAVBuffer(config);
358 EXPECT_EQ(avBufferQueueImpl_->AllocBuffer(buffer, config), Status::OK);
359 buffer->memory_->SetSize(config.size);
360 EXPECT_EQ(avBufferQueueImpl_->RequestReuseBuffer(buffer, config), Status::OK);
361 EXPECT_EQ(avBufferQueueImpl_->PushBuffer(buffer, true), Status::OK);
362 avBufferQueueImpl_->DeleteBuffers(buffer->GetUniqueId());
363 EXPECT_EQ(avBufferQueueImpl_->ReturnBuffer(buffer->GetUniqueId(), true), Status::ERROR_INVALID_BUFFER_ID);
364 }
365
366 /**
367 * @tc.name: RemoveBrokerListenerTest
368 * @tc.desc: Test RemoveBrokerListener interface
369 * @tc.type: FUNC
370 */
371 HWTEST_F(AVBufferQueueInnerUnitTest, RemoveBrokerListenerTest, TestSize.Level1)
372 {
373 avBufferQueueImpl_ = std::make_shared<AVBufferQueueImpl>(AVBUFFER_QUEUE_MAX_QUEUE_SIZE + 1,
374 MemoryType::SHARED_MEMORY, "RemoveBrokerListenerTest");
375 sptr<IBrokerListener> listener1 = new BrokerListener();
376 sptr<IBrokerListener> listener2 = new BrokerListener();
377 sptr<IBrokerListener> listener3 = new BrokerListener();
378 avBufferQueueImpl_->SetBrokerListener(listener1);
379 avBufferQueueImpl_->SetBrokerListener(listener2);
380 avBufferQueueImpl_->SetBrokerListener(listener3);
381 int32_t brokerListenersSize = avBufferQueueImpl_->brokerListeners_.size();
382 EXPECT_EQ(Status::OK, avBufferQueueImpl_->RemoveBrokerListener(listener3));
383 EXPECT_EQ(brokerListenersSize - 1, avBufferQueueImpl_->brokerListeners_.size());
384 EXPECT_EQ(Status::OK, avBufferQueueImpl_->RemoveBrokerListener(listener1));
385 EXPECT_EQ(brokerListenersSize - 1, avBufferQueueImpl_->brokerListeners_.size());
386 }
387
388 /**
389 * @tc.name: ClearTest
390 * @tc.desc: Test Clear interface
391 * @tc.type: FUNC
392 */
393 HWTEST_F(AVBufferQueueInnerUnitTest, ClearTest, TestSize.Level1)
394 {
395 AVBufferConfig config;
396 config.size = 1;
397 config.capacity = 1;
398 config.memoryType = MemoryType::VIRTUAL_MEMORY;
399 std::shared_ptr<AVAllocator> allocator = AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
400 std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer(allocator, 1, 1);
401 ASSERT_NE(nullptr, buffer);
402 sptr<IConsumerListener> listener = new ConsumerListener();
403 avBufferQueueImpl_->SetConsumerListener(listener);
404 EXPECT_EQ(Status::OK, avBufferQueueImpl_->AllocBuffer(buffer, config));
405 EXPECT_EQ(Status::OK, avBufferQueueImpl_->RequestReuseBuffer(buffer, config));
406 buffer->memory_->SetSize(1);
407 EXPECT_EQ(Status::OK, avBufferQueueImpl_->PushBuffer(buffer, true));
408 EXPECT_EQ(Status::OK, avBufferQueueImpl_->Clear());
409 }
410
411 /**
412 * @tc.name: ClearBufferIfTest
413 * @tc.desc: Test ClearBufferIf interface
414 * @tc.type: FUNC
415 */
416 HWTEST_F(AVBufferQueueInnerUnitTest, ClearBufferIfTest, TestSize.Level1)
417 {
418 sptr<IConsumerListener> listener = new ConsumerListener();
419 avBufferQueueImpl_->SetConsumerListener(listener);
420
421 AVBufferConfig config;
422 config.size = 1;
423 config.capacity = 1;
424 config.memoryType = MemoryType::VIRTUAL_MEMORY;
425
426 constexpr uint32_t totalBufferCount = 10;
427 for (uint32_t i = 0; i < totalBufferCount; i++) {
428 std::shared_ptr<AVAllocator> allocator =
429 AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
430 std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer(allocator, 1, 1);
431 ASSERT_NE(nullptr, buffer);
432 EXPECT_EQ(Status::OK, avBufferQueueImpl_->AllocBuffer(buffer, config));
433 EXPECT_EQ(Status::OK, avBufferQueueImpl_->RequestReuseBuffer(buffer, config));
434 buffer->memory_->SetSize(1);
435 buffer->pts_ = static_cast<int64_t>(i);
436 EXPECT_EQ(Status::OK, avBufferQueueImpl_->PushBuffer(buffer, true));
437 }
438 constexpr uint32_t startPts = 4;
__anon06731b120102(const std::shared_ptr<AVBuffer>& buffer) 439 auto isNewerSample = [](const std::shared_ptr<AVBuffer>& buffer) {
440 return (buffer != nullptr) && (buffer->pts_ >= startPts);
441 };
442 // clear pts remain pts from 0 ~ (startPts - 1 )
443 EXPECT_EQ(Status::OK, avBufferQueueImpl_->ClearBufferIf(isNewerSample));
444 EXPECT_EQ(startPts, avBufferQueueImpl_->GetFilledBufferSize());
445 }
446
447 /**
448 * @tc.name: GetFilledBufferSize_001
449 * @tc.desc: Test GetFilledBufferSize interface
450 * @tc.type: FUNC
451 */
452 HWTEST_F(AVBufferQueueInnerUnitTest, GetFilledBufferSize_001, TestSize.Level1)
453 {
454 EXPECT_EQ(avBufferQueueImpl_->GetFilledBufferSize(), 0);
455 EXPECT_EQ(avBufferQueueImpl_->SetQueueSize(2), Status::OK);
456
457 sptr<IConsumerListener> listener = new ConsumerListener();
458 avBufferQueueImpl_->SetConsumerListener(listener);
459
460 AVBufferConfig config;
461 config.size = 100;
462 config.capacity = 100;
463 config.memoryType = MemoryType::VIRTUAL_MEMORY;
464 std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer(config);
465 EXPECT_EQ(buffer->GetConfig().size, 0);
466
467 EXPECT_EQ(avBufferQueueImpl_->AttachBuffer(buffer, false), Status::OK);
468 EXPECT_EQ(buffer->GetConfig().size, 0);
469 EXPECT_EQ(avBufferQueueImpl_->GetFilledBufferSize(), 0);
470
471 EXPECT_EQ(avBufferQueueImpl_->RequestBuffer(buffer, config, 0), Status::OK);
472 EXPECT_EQ(buffer->GetConfig().size, 0);
473 EXPECT_EQ(avBufferQueueImpl_->GetFilledBufferSize(), 0);
474
475 EXPECT_EQ(avBufferQueueImpl_->PushBuffer(buffer, true), Status::ERROR_INVALID_BUFFER_SIZE);
476 EXPECT_EQ(buffer->GetConfig().size, 0);
477 EXPECT_EQ(avBufferQueueImpl_->GetFilledBufferSize(), 0);
478
479 EXPECT_EQ(avBufferQueueImpl_->RequestBuffer(buffer, config, 0), Status::OK);
480 EXPECT_EQ(buffer->GetConfig().size, 0);
481 EXPECT_EQ(avBufferQueueImpl_->GetFilledBufferSize(), 0);
482
483 buffer->memory_->SetSize(100);
484 EXPECT_EQ(avBufferQueueImpl_->PushBuffer(buffer, true), Status::OK);
485 EXPECT_EQ(buffer->GetConfig().size, 100);
486 EXPECT_EQ(avBufferQueueImpl_->GetFilledBufferSize(), 1);
487
488 std::shared_ptr<AVBuffer> bufferConsumer;
489 EXPECT_EQ(avBufferQueueImpl_->AcquireBuffer(bufferConsumer), Status::OK);
490 EXPECT_EQ(avBufferQueueImpl_->GetFilledBufferSize(), 0);
491
492 EXPECT_EQ(avBufferQueueImpl_->AcquireBuffer(bufferConsumer), Status::ERROR_NO_DIRTY_BUFFER);
493 EXPECT_EQ(avBufferQueueImpl_->GetFilledBufferSize(), 0);
494 }
495 } // namespace AVBufferQueueFuncUT
496 } // namespace Media
497 } // namespace OHOS
498