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: DeleteBuffersTest
130  * @tc.desc: Test delete buffers
131  * @tc.type: FUNC
132  */
133 HWTEST_F(AVBufferQueueInnerUnitTest, DeleteBuffersTest, TestSize.Level1)
134 {
135     sptr<IConsumerListener> listener = new ConsumerListener();
136     AVBufferConfig config;
137     config.size = 10;
138     config.memoryType = MemoryType::VIRTUAL_MEMORY;
139     avBufferQueueImpl_->SetConsumerListener(listener);
140     std::shared_ptr<AVBuffer> buffer1 = AVBuffer::CreateAVBuffer(config);
141     EXPECT_EQ(avBufferQueueImpl_->AllocBuffer(buffer1, config), Status::OK);
142     buffer1->memory_->SetSize(config.size);
143     EXPECT_EQ(avBufferQueueImpl_->RequestReuseBuffer(buffer1, config), Status::OK);
144     EXPECT_EQ(avBufferQueueImpl_->PushBuffer(buffer1, true), Status::OK);
145     config.capacity = 20;
146     std::shared_ptr<AVBuffer> buffer2 = AVBuffer::CreateAVBuffer(config);
147     EXPECT_EQ(avBufferQueueImpl_->AllocBuffer(buffer2, config), Status::OK);
148     buffer2->memory_->SetSize(config.size);
149     EXPECT_EQ(avBufferQueueImpl_->RequestReuseBuffer(buffer2, config), Status::OK);
150     EXPECT_EQ(avBufferQueueImpl_->PushBuffer(buffer2, true), Status::OK);
151 
152     uint32_t count = 10;
153     avBufferQueueImpl_->InsertFreeBufferInOrder(buffer1->GetUniqueId());
154     avBufferQueueImpl_->InsertFreeBufferInOrder(buffer2->GetUniqueId());
155     avBufferQueueImpl_->DeleteBuffers(count);
156     ASSERT_EQ(avBufferQueueImpl_->GetQueueSize(), 0);
157 
158     count = 0;
159     avBufferQueueImpl_->DeleteBuffers(count);
160     ASSERT_EQ(avBufferQueueImpl_->GetQueueSize(), 0);
161 }
162 
163 /**
164  * @tc.name: ChceckConfigTest
165  * @tc.desc: Test check config
166  * @tc.type: FUNC
167  */
168 HWTEST_F(AVBufferQueueInnerUnitTest, ChceckConfigTest, TestSize.Level1)
169 {
170     AVBufferConfig config;
171     int32_t size = 10;
172 
173     // memoryType : UNKNOWN_MEMORY
174     config.memoryType = MemoryType::UNKNOWN_MEMORY;
175     EXPECT_EQ(avBufferQueueImpl_->CheckConfig(config), Status::ERROR_UNEXPECTED_MEMORY_TYPE);
176 
177     // memoryType_ : UNKNOWN_MEMORY, memoryType : !UNKNOWN_MEMORY
178     config.memoryType = MemoryType::SHARED_MEMORY;
179     avBufferQueueImpl_ = std::make_shared<AVBufferQueueImpl>(size, MemoryType::UNKNOWN_MEMORY, "test");
180     EXPECT_EQ(avBufferQueueImpl_->CheckConfig(config), Status::OK);
181 
182     // memoryType_ : !UNKNOWN_MEMORY, memoryType : != memoryType_
183     config.memoryType = MemoryType::VIRTUAL_MEMORY;
184     avBufferQueueImpl_ = std::make_shared<AVBufferQueueImpl>(size, MemoryType::SHARED_MEMORY, "test");
185     EXPECT_EQ(avBufferQueueImpl_->CheckConfig(config), Status::ERROR_UNEXPECTED_MEMORY_TYPE);
186 
187     // memoryType_ : !UNKNOWN_MEMORY, memoryType : == memoryType_
188     config.memoryType = MemoryType::SHARED_MEMORY;
189     avBufferQueueImpl_ = std::make_shared<AVBufferQueueImpl>(size, MemoryType::SHARED_MEMORY, "test");
190     EXPECT_EQ(avBufferQueueImpl_->CheckConfig(config), Status::OK);
191 }
192 
193 /**
194  * @tc.name: PushBufferTest_001
195  * @tc.desc: Test push buffer interface
196  * @tc.type: FUNC
197  */
198 HWTEST_F(AVBufferQueueInnerUnitTest, PushBufferTest_001, TestSize.Level1)
199 {
200     AVBufferConfig config;
201     config.size = 100;
202     config.memoryType = MemoryType::VIRTUAL_MEMORY;
203     std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer(config);
204     EXPECT_EQ(avBufferQueueImpl_->AllocBuffer(buffer, config), Status::OK);
205 
206     EXPECT_EQ(avBufferQueueImpl_->RequestReuseBuffer(buffer, config), Status::OK);
207     EXPECT_EQ(avBufferQueueImpl_->PushBuffer(buffer, true), Status::ERROR_INVALID_BUFFER_SIZE);
208 }
209 
210 /**
211  * @tc.name: PushBufferTest_002
212  * @tc.desc: Test push buffer interface
213  * @tc.type: FUNC
214  */
215 HWTEST_F(AVBufferQueueInnerUnitTest, PushBufferTest_002, TestSize.Level1)
216 {
217     AVBufferConfig config;
218     config.size = 100;
219     config.memoryType = MemoryType::VIRTUAL_MEMORY;
220     std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer(config);
221     EXPECT_EQ(avBufferQueueImpl_->AllocBuffer(buffer, config), Status::OK);
222 
223     EXPECT_EQ(avBufferQueueImpl_->PushBuffer(buffer, true), Status::ERROR_INVALID_BUFFER_STATE);
224 }
225 
226 /**
227  * @tc.name: PushBufferTest_003
228  * @tc.desc: Test push buffer interface
229  * @tc.type: FUNC
230  */
231 HWTEST_F(AVBufferQueueInnerUnitTest, PushBufferTest_003, TestSize.Level1)
232 {
233     AVBufferConfig config;
234     config.size = -1;
235     config.capacity = 0;
236     config.memoryType = MemoryType::VIRTUAL_MEMORY;
237     std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer(config);
238     ASSERT_NE(nullptr, buffer);
239     EXPECT_EQ(avBufferQueueImpl_->AllocBuffer(buffer, config), Status::OK);
240     EXPECT_EQ(avBufferQueueImpl_->RequestReuseBuffer(buffer, config), Status::OK);
241     EXPECT_EQ(avBufferQueueImpl_->PushBuffer(buffer, true), Status::ERROR_INVALID_BUFFER_SIZE);
242 }
243 
244 /**
245  * @tc.name: PushBufferTest_004
246  * @tc.desc: Test push buffer interface
247  * @tc.type: FUNC
248  */
249 HWTEST_F(AVBufferQueueInnerUnitTest, PushBufferTest_004, TestSize.Level1)
250 {
251     AVBufferConfig config;
252     config.size = 1;
253     config.capacity = 1;
254     config.memoryType = MemoryType::VIRTUAL_MEMORY;
255     std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer(config);
256     ASSERT_NE(nullptr, buffer);
257     EXPECT_EQ(avBufferQueueImpl_->AllocBuffer(buffer, config), Status::OK);
258     avBufferQueueImpl_->DeleteBuffers(1);
259     EXPECT_EQ(avBufferQueueImpl_->PushBuffer(buffer, true), Status::OK);
260 }
261 
262 /**
263  * @tc.name: PushBufferTest_005
264  * @tc.desc: Test push buffer interface
265  * @tc.type: FUNC
266  */
267 HWTEST_F(AVBufferQueueInnerUnitTest, PushBufferTest_005, TestSize.Level1)
268 {
269     AVBufferConfig config;
270     config.size = 1;
271     config.capacity = 1;
272     config.memoryType = MemoryType::VIRTUAL_MEMORY;
273     std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer(config);
274     ASSERT_NE(nullptr, buffer);
275     EXPECT_EQ(avBufferQueueImpl_->AllocBuffer(buffer, config), Status::OK);
276     EXPECT_EQ(avBufferQueueImpl_->RequestReuseBuffer(buffer, config), Status::OK);
277     sptr<IBrokerListener> listener = new BrokerListener();
278     avBufferQueueImpl_->SetBrokerListener(listener);
279     EXPECT_EQ(avBufferQueueImpl_->PushBuffer(buffer, true), Status::OK);
280 }
281 
282 /**
283  * @tc.name: PushBufferTest_006
284  * @tc.desc: Test push buffer interface
285  * @tc.type: FUNC
286  */
287 HWTEST_F(AVBufferQueueInnerUnitTest, PushBufferTest_006, TestSize.Level1)
288 {
289     AVBufferConfig config;
290     config.size = 1;
291     config.capacity = 1;
292     config.memoryType = MemoryType::VIRTUAL_MEMORY;
293     std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer(config);
294     ASSERT_NE(nullptr, buffer);
295     EXPECT_EQ(avBufferQueueImpl_->AllocBuffer(buffer, config), Status::OK);
296     EXPECT_EQ(avBufferQueueImpl_->RequestReuseBuffer(buffer, config), Status::OK);
297     sptr<IBrokerListener> listener = new BrokerListener();
298     avBufferQueueImpl_->SetBrokerListener(listener);
299     EXPECT_EQ(avBufferQueueImpl_->PushBuffer(buffer, false), Status::OK);
300 }
301 
302 /**
303  * @tc.name: ReturnBufferTest
304  * @tc.desc: Test return buffer interface
305  * @tc.type: FUNC
306  */
307 HWTEST_F(AVBufferQueueInnerUnitTest, ReturnBufferTest, TestSize.Level1)
308 {
309     sptr<IConsumerListener> listener = new ConsumerListener();
310     AVBufferConfig config;
311     config.size = 1;
312     config.capacity = 1;
313     config.memoryType = MemoryType::VIRTUAL_MEMORY;
314     avBufferQueueImpl_->SetConsumerListener(listener);
315     std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer(config);
316     ASSERT_NE(nullptr, buffer);
317     EXPECT_EQ(avBufferQueueImpl_->AllocBuffer(buffer, config), Status::OK);
318     buffer->memory_->SetSize(config.size);
319     EXPECT_EQ(avBufferQueueImpl_->RequestReuseBuffer(buffer, config), Status::OK);
320     EXPECT_EQ(avBufferQueueImpl_->PushBuffer(buffer, true), Status::OK);
321     EXPECT_EQ(avBufferQueueImpl_->AcquireBuffer(buffer), Status::OK);
322 
323     EXPECT_EQ(avBufferQueueImpl_->ReleaseBuffer(buffer->GetUniqueId()), Status::OK);
324     EXPECT_EQ(avBufferQueueImpl_->ReturnBuffer(buffer, false), Status::ERROR_INVALID_BUFFER_STATE);
325 
326     buffer = AVBuffer::CreateAVBuffer(config);
327     EXPECT_EQ(avBufferQueueImpl_->AllocBuffer(buffer, config), Status::OK);
328     buffer->memory_->SetSize(config.size);
329     EXPECT_EQ(avBufferQueueImpl_->RequestReuseBuffer(buffer, config), Status::OK);
330     EXPECT_EQ(avBufferQueueImpl_->PushBuffer(buffer, true), Status::OK);
331     EXPECT_EQ(avBufferQueueImpl_->ReturnBuffer(buffer, true), Status::ERROR_INVALID_BUFFER_STATE);
332 
333     EXPECT_EQ(avBufferQueueImpl_->ReturnBuffer(2, true), Status::ERROR_INVALID_BUFFER_ID);
334 
335     buffer = AVBuffer::CreateAVBuffer(config);
336     EXPECT_EQ(avBufferQueueImpl_->AllocBuffer(buffer, config), Status::OK);
337     buffer->memory_->SetSize(config.size);
338     EXPECT_EQ(avBufferQueueImpl_->RequestReuseBuffer(buffer, config), Status::OK);
339     EXPECT_EQ(avBufferQueueImpl_->PushBuffer(buffer, true), Status::OK);
340     avBufferQueueImpl_->DeleteBuffers(buffer->GetUniqueId());
341     EXPECT_EQ(avBufferQueueImpl_->ReturnBuffer(buffer->GetUniqueId(), true), Status::ERROR_INVALID_BUFFER_ID);
342 }
343 } // namespace AVBufferQueueFuncUT
344 } // namespace Media
345 } // namespace OHOS
346