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_unit_test.h"
17 #include "av_hardware_allocator.h"
18 #include "av_hardware_memory.h"
19 #include "av_shared_allocator.h"
20 #include "av_shared_memory_ext.h"
21 #include "av_surface_allocator.h"
22 #include "av_surface_memory.h"
23 #include "avbuffer_mock.h"
24 #include "avbuffer_utils.h"
25 #include "unittest_log.h"
26 
27 using namespace std;
28 using namespace testing::ext;
29 
30 namespace OHOS {
31 namespace Media {
32 namespace AVBufferUT {
SetUpTestCase(void)33 void AVBufferInnerUnitTest::SetUpTestCase(void)
34 {
35     std::cout << "[SetUpTestCase]: SetUp!!!" << std::endl;
36 }
37 
TearDownTestCase(void)38 void AVBufferInnerUnitTest::TearDownTestCase(void)
39 {
40     std::cout << "[TearDownTestCase]: over!!!" << std::endl;
41 }
42 
SetUp(void)43 void AVBufferInnerUnitTest::SetUp(void)
44 {
45     std::cout << "[SetUp]: SetUp!!!";
46     meta_ = std::make_shared<Meta>();
47     const ::testing::TestInfo *testInfo_ = ::testing::UnitTest::GetInstance()->current_test_info();
48     std::string testName = testInfo_->name();
49     std::cout << testName << std::endl;
50     parcel_ = nullptr;
51     if (inputBuffer_.size() < TEST_BUFFER_SIZE) {
52         inputBuffer_.resize(TEST_BUFFER_SIZE);
53         for (int32_t i = 0; i < TEST_BUFFER_SIZE; ++i) {
54             inputBuffer_[i] = i % 256; // 256: uint8_t range
55         }
56     }
57     vector<uint8_t> temp(TEST_BUFFER_SIZE, 0);
58     swap(temp, outputBuffer_);
59 }
60 
TearDown(void)61 void AVBufferInnerUnitTest::TearDown(void)
62 {
63     allocator_ = nullptr;
64     buffer_ = nullptr;
65     meta_ = nullptr;
66     parcel_ = nullptr;
67     for (auto &buffer : dmaBufferLst_) {
68         DmabufHeapBufferFree(&buffer);
69     }
70     std::vector<DmabufHeapBuffer> tmp;
71     swap(tmp, dmaBufferLst_);
72     std::cout << "[TearDown]: over!!!" << std::endl;
73 }
74 
CreateLocalHardwareMem()75 void AVBufferInnerUnitTest::CreateLocalHardwareMem()
76 {
77     // create loacal
78     DmabufHeapBuffer dmaBuffer = {.size = capacity_, .heapFlags = 0};
79     int32_t dmaHeapFd = HardwareHeapFactory::GetInstance().GetHardwareHeapFd();
80     DmabufHeapBufferAlloc(dmaHeapFd, &dmaBuffer);
81     dmaBufferLst_.push_back(dmaBuffer);
82 
83     allocator_ = AVAllocatorFactory::CreateHardwareAllocator(dmaBuffer.fd, capacity_, memFlag_);
84     ASSERT_NE(nullptr, allocator_);
85     remoteBuffer_ = buffer_ = AVBuffer::CreateAVBuffer(allocator_, capacity_, align_);
86     ASSERT_NE(nullptr, buffer_);
87     ASSERT_NE(nullptr, buffer_->memory_->GetAddr());
88 }
89 
CreateLocalHardwareMemSecure()90 void AVBufferInnerUnitTest::CreateLocalHardwareMemSecure()
91 {
92     // create loacal
93     DmabufHeapBuffer dmaBuffer = {.size = capacity_, .heapFlags = 0};
94     int32_t dmaHeapFd = HardwareHeapFactory::GetInstance().GetHardwareHeapFd();
95     DmabufHeapBufferAlloc(dmaHeapFd, &dmaBuffer);
96     dmaBufferLst_.push_back(dmaBuffer);
97 
98     allocator_ = AVAllocatorFactory::CreateHardwareAllocator(dmaBuffer.fd, capacity_, memFlag_, true);
99     ASSERT_NE(nullptr, allocator_);
100     remoteBuffer_ = buffer_ = AVBuffer::CreateAVBuffer(allocator_, capacity_, align_);
101     ASSERT_NE(nullptr, buffer_);
102     ASSERT_EQ(nullptr, buffer_->memory_->GetAddr());
103 }
104 
CreateLocalHardwareMemByConfig()105 void AVBufferInnerUnitTest::CreateLocalHardwareMemByConfig()
106 {
107     // create loacal
108     DmabufHeapBuffer dmaBuffer = {.size = capacity_, .heapFlags = 0};
109     int32_t dmaHeapFd = HardwareHeapFactory::GetInstance().GetHardwareHeapFd();
110     DmabufHeapBufferAlloc(dmaHeapFd, &dmaBuffer);
111     dmaBufferLst_.push_back(dmaBuffer);
112 
113     config_.dmaFd = dmaBuffer.fd;
114     config_.size = capacity_;
115     config_.memoryFlag = memFlag_;
116     config_.memoryType = MemoryType::HARDWARE_MEMORY;
117     remoteBuffer_ = buffer_ = AVBuffer::CreateAVBuffer(config_);
118     ASSERT_NE(nullptr, buffer_);
119     ASSERT_NE(nullptr, buffer_->memory_->GetAddr());
120 }
121 
CreateRemoteHardwareMem()122 void AVBufferInnerUnitTest::CreateRemoteHardwareMem()
123 {
124     parcel_ = std::make_shared<MessageParcel>();
125     // create remote
126     CreateLocalHardwareMem();
127     buffer_ = nullptr;
128     ASSERT_FALSE((allocator_ == nullptr) || (remoteBuffer_ == nullptr) || (remoteBuffer_->memory_ == nullptr));
129     std::cout << "remote fd: " << remoteBuffer_->memory_->GetFileDescriptor() << "\n";
130 }
131 
CreateLocalSharedMem()132 void AVBufferInnerUnitTest::CreateLocalSharedMem()
133 {
134     // create loacal
135     allocator_ = AVAllocatorFactory::CreateSharedAllocator(memFlag_);
136     ASSERT_NE(nullptr, allocator_);
137     remoteBuffer_ = buffer_ = AVBuffer::CreateAVBuffer(allocator_, capacity_, align_);
138     ASSERT_NE(nullptr, buffer_);
139     ASSERT_NE(nullptr, buffer_->memory_->GetAddr());
140 }
141 
CreateLocalSharedMemByConfig()142 void AVBufferInnerUnitTest::CreateLocalSharedMemByConfig()
143 {
144     // create loacal
145     config_.align = align_;
146     config_.size = capacity_;
147     config_.memoryFlag = memFlag_;
148     config_.memoryType = MemoryType::SHARED_MEMORY;
149     remoteBuffer_ = buffer_ = AVBuffer::CreateAVBuffer(config_);
150     ASSERT_NE(nullptr, buffer_);
151     ASSERT_NE(nullptr, buffer_->memory_->GetAddr());
152 }
153 
CreateRemoteSharedMem()154 void AVBufferInnerUnitTest::CreateRemoteSharedMem()
155 {
156     parcel_ = std::make_shared<MessageParcel>();
157     // create remote
158     CreateLocalSharedMem();
159     buffer_ = nullptr;
160     ASSERT_FALSE((allocator_ == nullptr) || (remoteBuffer_ == nullptr) || (remoteBuffer_->memory_ == nullptr));
161     std::cout << "remote fd: " << remoteBuffer_->memory_->GetFileDescriptor() << "\n";
162 }
163 
CreateLocalSurfaceMem()164 void AVBufferInnerUnitTest::CreateLocalSurfaceMem()
165 {
166     // create loacal
167     allocator_ = AVAllocatorFactory::CreateSurfaceAllocator(DEFAULT_CONFIG);
168     ASSERT_NE(nullptr, allocator_);
169     remoteBuffer_ = buffer_ = AVBuffer::CreateAVBuffer(allocator_, capacity_, align_);
170     ASSERT_NE(nullptr, buffer_);
171     ASSERT_NE(nullptr, buffer_->memory_->GetAddr());
172 }
173 
CreateLocalSurfaceMemByConfig()174 void AVBufferInnerUnitTest::CreateLocalSurfaceMemByConfig()
175 {
176     // create loacal
177     *(config_.surfaceBufferConfig) = DEFAULT_CONFIG;
178     config_.memoryType = MemoryType::SURFACE_MEMORY;
179     remoteBuffer_ = buffer_ = AVBuffer::CreateAVBuffer(config_);
180     ASSERT_NE(nullptr, buffer_);
181     ASSERT_NE(nullptr, buffer_->memory_->GetAddr());
182 }
183 
CreateRemoteSurfaceMem()184 void AVBufferInnerUnitTest::CreateRemoteSurfaceMem()
185 {
186     parcel_ = std::make_shared<MessageParcel>();
187     // create remote
188     CreateLocalSurfaceMem();
189     buffer_ = nullptr;
190     ASSERT_FALSE((allocator_ == nullptr) || (remoteBuffer_ == nullptr) || (remoteBuffer_->memory_ == nullptr));
191     std::cout << "remote fd: " << remoteBuffer_->memory_->GetFileDescriptor() << "\n";
192 }
193 
CreateLocalSurfaceMemByParcel()194 void AVBufferInnerUnitTest::CreateLocalSurfaceMemByParcel()
195 {
196     MessageParcel parcel;
197     sptr<SurfaceBuffer> surfaceBuffer = SurfaceBuffer::Create();
198     (void)surfaceBuffer->Alloc(DEFAULT_CONFIG);
199     (void)surfaceBuffer->WriteToMessageParcel(parcel);
200     // create local
201     remoteBuffer_ = buffer_ = AVBuffer::CreateAVBuffer();
202     ASSERT_NE(nullptr, buffer_);
203     ASSERT_TRUE(buffer_->ReadFromMessageParcel(parcel, true));
204     ASSERT_NE(nullptr, buffer_->memory_->GetAddr());
205 }
206 
CreateLocalSurfaceMemBySptr()207 void AVBufferInnerUnitTest::CreateLocalSurfaceMemBySptr()
208 {
209     sptr<SurfaceBuffer> surfaceBuffer = SurfaceBuffer::Create();
210     (void)surfaceBuffer->Alloc(DEFAULT_CONFIG);
211     // create local
212     remoteBuffer_ = buffer_ = AVBuffer::CreateAVBuffer(surfaceBuffer);
213     ASSERT_NE(nullptr, buffer_);
214     ASSERT_NE(nullptr, buffer_->memory_);
215     ASSERT_NE(nullptr, buffer_->memory_->GetAddr());
216 }
217 
CreateRemoteSurfaceMemByParcel()218 void AVBufferInnerUnitTest::CreateRemoteSurfaceMemByParcel()
219 {
220     parcel_ = std::make_shared<MessageParcel>();
221     // create remote
222     CreateLocalSurfaceMemByParcel();
223     buffer_ = nullptr;
224     ASSERT_FALSE((remoteBuffer_ == nullptr) || (remoteBuffer_->memory_ == nullptr));
225     std::cout << "remote fd: " << remoteBuffer_->memory_->GetFileDescriptor() << "\n";
226 }
227 
CreateRemoteSurfaceMemBySptr()228 void AVBufferInnerUnitTest::CreateRemoteSurfaceMemBySptr()
229 {
230     parcel_ = std::make_shared<MessageParcel>();
231     // create remote
232     CreateLocalSurfaceMemBySptr();
233     buffer_ = nullptr;
234     ASSERT_FALSE((remoteBuffer_ == nullptr) || (remoteBuffer_->memory_ == nullptr));
235     std::cout << "remote fd: " << remoteBuffer_->memory_->GetFileDescriptor() << "\n";
236 }
237 
CreateLocalVirtualMem()238 void AVBufferInnerUnitTest::CreateLocalVirtualMem()
239 {
240     // create loacal
241     allocator_ = AVAllocatorFactory::CreateVirtualAllocator();
242     remoteBuffer_ = buffer_ = AVBuffer::CreateAVBuffer(allocator_, capacity_, align_);
243     ASSERT_NE(nullptr, buffer_);
244     ASSERT_NE(nullptr, buffer_->memory_->GetAddr());
245 }
246 
CreateLocalVirtualMemByConfig()247 void AVBufferInnerUnitTest::CreateLocalVirtualMemByConfig()
248 {
249     // create loacal
250     config_.align = align_;
251     config_.size = capacity_;
252     config_.memoryType = MemoryType::VIRTUAL_MEMORY;
253     remoteBuffer_ = buffer_ = AVBuffer::CreateAVBuffer(config_);
254     ASSERT_NE(nullptr, buffer_);
255     ASSERT_NE(nullptr, buffer_->memory_->GetAddr());
256 }
257 
CreateLocalNullMem()258 void AVBufferInnerUnitTest::CreateLocalNullMem()
259 {
260     parcel_ = std::make_shared<MessageParcel>();
261     // create remote
262     remoteBuffer_ = AVBuffer::CreateAVBuffer();
263     ASSERT_NE(nullptr, remoteBuffer_);
264 }
265 
GetRemoteBuffer()266 void AVBufferInnerUnitTest::GetRemoteBuffer()
267 {
268     bool ret = remoteBuffer_->WriteToMessageParcel(*parcel_);
269     ASSERT_TRUE(ret);
270     // create loacal
271     buffer_ = AVBuffer::CreateAVBuffer();
272     ASSERT_NE(nullptr, buffer_);
273 
274     ret = buffer_->ReadFromMessageParcel(*parcel_);
275     ASSERT_TRUE(ret);
276     if (buffer_->memory_ != nullptr) {
277         ASSERT_NE(nullptr, buffer_->memory_->GetAddr());
278         std::cout << "local fd: " << buffer_->memory_->GetFileDescriptor() << "\n";
279     }
280 }
281 
CheckMetaTransParcel()282 void AVBufferInnerUnitTest::CheckMetaTransParcel()
283 {
284     int32_t getIntValue = 0;
285     int64_t getLongValue = 0;
286     double getDoubleValue = 0.0;
287     std::string getStringValue = "";
288     MessageParcel parcel;
289     for (int32_t toIndex = 0; toIndex < TEST_LOOP_DEPTH; ++toIndex) {
290         ASSERT_TRUE(meta_->ToParcel(parcel));
291     }
292     for (int32_t fromIndex = 0; fromIndex < TEST_LOOP_DEPTH; ++fromIndex) {
293         ASSERT_TRUE(meta_->FromParcel(parcel));
294         meta_->GetData(INT_TESTKEY, getIntValue);
295         meta_->GetData(LONG_TESTKEY, getLongValue);
296         meta_->GetData(DOUBLE_TESTKEY, getDoubleValue);
297         meta_->GetData(STRING_TESTKEY, getStringValue);
298 
299         EXPECT_EQ(getIntValue, INTVALUE);
300         EXPECT_EQ(getLongValue, LONGVALUE);
301         EXPECT_EQ(getDoubleValue, DOUBLEVALUE);
302         EXPECT_EQ(getStringValue, STRINGVALUE);
303     }
304 }
305 
CheckMetaSetAndGet()306 void AVBufferInnerUnitTest::CheckMetaSetAndGet()
307 {
308     int32_t getIntValue = 0;
309     int64_t getLongValue = 0;
310     double getDoubleValue = 0.0;
311     std::string getStringValue = "";
312 
313     remoteBuffer_->pts_ = DEFAULT_PTS;
314     remoteBuffer_->dts_ = DEFAULT_DTS;
315     remoteBuffer_->duration_ = DEFAULT_DURATION;
316     remoteBuffer_->flag_ = DEFAULT_FLAG;
317 
318     meta_->SetData(INT_TESTKEY, INTVALUE);
319     meta_->SetData(LONG_TESTKEY, LONGVALUE);
320     meta_->SetData(DOUBLE_TESTKEY, DOUBLEVALUE);
321     meta_->SetData(STRING_TESTKEY, STRINGVALUE);
322     CheckMetaTransParcel();
323     remoteBuffer_->meta_ = meta_;
324 
325     if (parcel_ != nullptr) {
326         GetRemoteBuffer();
327         ASSERT_EQ(remoteBuffer_->GetUniqueId(), buffer_->GetUniqueId());
328         ASSERT_FALSE((buffer_ == nullptr) || (buffer_->memory_ == nullptr));
329     }
330     ASSERT_NE(nullptr, buffer_->meta_);
331     EXPECT_EQ(buffer_->pts_, DEFAULT_PTS);
332     EXPECT_EQ(buffer_->dts_, DEFAULT_DTS);
333     EXPECT_EQ(buffer_->duration_, DEFAULT_DURATION);
334     EXPECT_EQ(buffer_->flag_, DEFAULT_FLAG);
335 
336     buffer_->meta_->GetData(INT_TESTKEY, getIntValue);
337     buffer_->meta_->GetData(LONG_TESTKEY, getLongValue);
338     buffer_->meta_->GetData(DOUBLE_TESTKEY, getDoubleValue);
339     buffer_->meta_->GetData(STRING_TESTKEY, getStringValue);
340 
341     EXPECT_EQ(getIntValue, INTVALUE);
342     EXPECT_EQ(getLongValue, LONGVALUE);
343     EXPECT_EQ(getDoubleValue, DOUBLEVALUE);
344     EXPECT_EQ(getStringValue, STRINGVALUE);
345 }
346 
CheckAttrTrans()347 void AVBufferInnerUnitTest::CheckAttrTrans()
348 {
349     remoteBuffer_->pts_ = DEFAULT_PTS;
350     remoteBuffer_->dts_ = DEFAULT_DTS;
351     remoteBuffer_->duration_ = DEFAULT_DURATION;
352     remoteBuffer_->flag_ = DEFAULT_FLAG;
353 
354     GetRemoteBuffer();
355     ASSERT_EQ(remoteBuffer_->GetUniqueId(), buffer_->GetUniqueId());
356     ASSERT_FALSE(buffer_ == nullptr);
357 
358     EXPECT_EQ(buffer_->pts_, DEFAULT_PTS);
359     EXPECT_EQ(buffer_->dts_, DEFAULT_DTS);
360     EXPECT_EQ(buffer_->duration_, DEFAULT_DURATION);
361     EXPECT_EQ(buffer_->flag_, DEFAULT_FLAG);
362 
363     for (int32_t i = 0; i < TEST_LOOP_DEPTH; i++) {
364         remoteBuffer_->pts_++;
365         remoteBuffer_->dts_++;
366         remoteBuffer_->duration_++;
367         remoteBuffer_->flag_++;
368 
369         ASSERT_TRUE(remoteBuffer_->WriteToMessageParcel(*parcel_));
370         ASSERT_TRUE(remoteBuffer_->WriteToMessageParcel(*parcel_));
371         ASSERT_TRUE(buffer_->ReadFromMessageParcel(*parcel_));
372         ASSERT_TRUE(buffer_->ReadFromMessageParcel(*parcel_));
373 
374         EXPECT_EQ(buffer_->pts_, remoteBuffer_->pts_);
375         EXPECT_EQ(buffer_->dts_, remoteBuffer_->dts_);
376         EXPECT_EQ(buffer_->duration_, remoteBuffer_->duration_);
377         EXPECT_EQ(buffer_->flag_, remoteBuffer_->flag_);
378     }
379 }
380 
CheckMemTrans()381 void AVBufferInnerUnitTest::CheckMemTrans()
382 {
383     outputBuffer_.resize(TEST_BUFFER_SIZE, 0);
384     int32_t pos = capacity_ / 2;
385     int32_t length = capacity_ - pos;
386     auto error = memcpy_s(remoteBuffer_->memory_->GetAddr(), pos, inputBuffer_.data(), pos);
387     EXPECT_EQ(error, EOK);
388     remoteBuffer_->memory_->SetSize(pos);
389     EXPECT_EQ(remoteBuffer_->memory_->Write(inputBuffer_.data() + pos, length, -1), length);
390     EXPECT_EQ(remoteBuffer_->memory_->Read(outputBuffer_.data(), capacity_, 0), capacity_);
391     uint8_t *addr = remoteBuffer_->memory_->GetAddr();
392     ASSERT_NE(addr, nullptr);
393     EXPECT_EQ(remoteBuffer_->memory_->GetSize(), capacity_);
394     EXPECT_EQ(memcmp(inputBuffer_.data(), outputBuffer_.data(), capacity_), 0);
395     EXPECT_EQ(memcmp(static_cast<void *>(addr), inputBuffer_.data(), capacity_), 0);
396     EXPECT_EQ(memcmp(static_cast<void *>(addr), outputBuffer_.data(), capacity_), 0);
397     if (parcel_ != nullptr) {
398         GetRemoteBuffer();
399         ASSERT_EQ(remoteBuffer_->GetUniqueId(), buffer_->GetUniqueId());
400         ASSERT_FALSE((buffer_ == nullptr) || (buffer_->memory_ == nullptr));
401     }
402     ASSERT_EQ(buffer_->memory_->GetSize(), capacity_);
403     addr = buffer_->memory_->GetAddr();
404     EXPECT_EQ(buffer_->memory_->Read(outputBuffer_.data(), capacity_, 0), capacity_);
405     EXPECT_EQ(memcmp(inputBuffer_.data(), outputBuffer_.data(), capacity_), 0);
406     EXPECT_EQ(memcmp(static_cast<void *>(addr), inputBuffer_.data(), capacity_), 0);
407     EXPECT_EQ(memcmp(static_cast<void *>(addr), outputBuffer_.data(), capacity_), 0);
408 }
409 
CheckMemTransPos(int32_t pos)410 void AVBufferInnerUnitTest::CheckMemTransPos(int32_t pos)
411 {
412     outputBuffer_.resize(TEST_BUFFER_SIZE, 0);
413     capacity_ = remoteBuffer_->memory_->GetCapacity();
414     int32_t length = capacity_ - pos;
415     EXPECT_EQ(remoteBuffer_->memory_->Write(inputBuffer_.data() + pos, length, pos), length);
416     EXPECT_EQ(remoteBuffer_->memory_->Read(outputBuffer_.data() + pos, length, pos), length);
417     uint8_t *addr = remoteBuffer_->memory_->GetAddr();
418     ASSERT_NE(addr, nullptr);
419     EXPECT_EQ(remoteBuffer_->memory_->GetSize(), capacity_);
420     EXPECT_EQ(memcmp(inputBuffer_.data() + pos, outputBuffer_.data() + pos, length), 0);
421     EXPECT_EQ(memcmp(static_cast<void *>(addr + pos), inputBuffer_.data() + pos, length), 0);
422     EXPECT_EQ(memcmp(static_cast<void *>(addr + pos), outputBuffer_.data() + pos, length), 0);
423     if (parcel_ != nullptr) {
424         GetRemoteBuffer();
425         ASSERT_EQ(remoteBuffer_->GetUniqueId(), buffer_->GetUniqueId());
426         ASSERT_FALSE((buffer_ == nullptr) || (buffer_->memory_ == nullptr));
427     }
428     ASSERT_EQ(buffer_->memory_->GetSize(), capacity_);
429     addr = buffer_->memory_->GetAddr();
430     EXPECT_EQ(buffer_->memory_->Read(outputBuffer_.data() + pos, length, pos), length);
431     EXPECT_EQ(memcmp(inputBuffer_.data() + pos, outputBuffer_.data() + pos, length), 0);
432     EXPECT_EQ(memcmp(static_cast<void *>(addr + pos), inputBuffer_.data() + pos, length), 0);
433     EXPECT_EQ(memcmp(static_cast<void *>(addr + pos), outputBuffer_.data() + pos, length), 0);
434 }
435 
CheckMemTransOutOfRange(int32_t pos)436 void AVBufferInnerUnitTest::CheckMemTransOutOfRange(int32_t pos)
437 {
438     outputBuffer_.resize(TEST_BUFFER_SIZE, 0);
439     capacity_ = remoteBuffer_->memory_->GetCapacity();
440     int32_t length = capacity_ - pos;
441     EXPECT_EQ(remoteBuffer_->memory_->Write(inputBuffer_.data() + pos, length + 1, pos), length);
442     EXPECT_EQ(remoteBuffer_->memory_->Read(outputBuffer_.data() + pos, length + 1, pos), length);
443     uint8_t *addr = remoteBuffer_->memory_->GetAddr();
444     ASSERT_NE(addr, nullptr);
445     EXPECT_EQ(remoteBuffer_->memory_->GetSize(), capacity_);
446     EXPECT_EQ(memcmp(inputBuffer_.data() + pos, outputBuffer_.data() + pos, length), 0);
447     EXPECT_EQ(memcmp(static_cast<void *>(addr + pos), inputBuffer_.data() + pos, length), 0);
448     EXPECT_EQ(memcmp(static_cast<void *>(addr + pos), outputBuffer_.data() + pos, length), 0);
449     if (parcel_ != nullptr) {
450         GetRemoteBuffer();
451         ASSERT_EQ(remoteBuffer_->GetUniqueId(), buffer_->GetUniqueId());
452         ASSERT_FALSE((buffer_ == nullptr) || (buffer_->memory_ == nullptr));
453     }
454     ASSERT_EQ(buffer_->memory_->GetSize(), capacity_);
455     addr = buffer_->memory_->GetAddr();
456     EXPECT_EQ(buffer_->memory_->Read(outputBuffer_.data() + pos, length + 1, pos), length);
457     EXPECT_EQ(memcmp(inputBuffer_.data() + pos, outputBuffer_.data() + pos, length), 0);
458     EXPECT_EQ(memcmp(static_cast<void *>(addr + pos), inputBuffer_.data() + pos, length), 0);
459     EXPECT_EQ(memcmp(static_cast<void *>(addr + pos), outputBuffer_.data() + pos, length), 0);
460 }
461 
CheckDataSize()462 void AVBufferInnerUnitTest::CheckDataSize()
463 {
464     capacity_ = remoteBuffer_->memory_->GetCapacity();
465     EXPECT_EQ(Status::OK, remoteBuffer_->memory_->SetSize(capacity_ - 1));
466     EXPECT_EQ(remoteBuffer_->memory_->GetSize(), capacity_ - 1);
467     EXPECT_EQ(Status::OK, remoteBuffer_->memory_->SetSize(0));
468     EXPECT_EQ(remoteBuffer_->memory_->GetSize(), 0);
469     EXPECT_EQ(Status::OK, remoteBuffer_->memory_->SetSize(1));
470     EXPECT_EQ(remoteBuffer_->memory_->GetSize(), 1);
471     EXPECT_EQ(Status::ERROR_INVALID_PARAMETER, remoteBuffer_->memory_->SetSize(-1));
472     EXPECT_EQ(remoteBuffer_->memory_->GetSize(), 1);
473     EXPECT_EQ(Status::ERROR_INVALID_PARAMETER, remoteBuffer_->memory_->SetSize(capacity_ + 1));
474     EXPECT_EQ(remoteBuffer_->memory_->GetSize(), 1);
475     EXPECT_EQ(Status::OK, remoteBuffer_->memory_->SetSize(capacity_));
476     EXPECT_EQ(remoteBuffer_->memory_->GetSize(), capacity_);
477     if (parcel_ != nullptr) {
478         GetRemoteBuffer();
479         ASSERT_EQ(remoteBuffer_->GetUniqueId(), buffer_->GetUniqueId());
480         ASSERT_FALSE((buffer_ == nullptr) || (buffer_->memory_ == nullptr));
481     }
482     EXPECT_EQ(buffer_->memory_->GetSize(), capacity_);
483 }
484 
HardwareHeapFactory()485 HardwareHeapFactory::HardwareHeapFactory()
486 {
487     std::string rootDir = "/dev/dma_heap/";
488     DIR *dir = opendir(rootDir.c_str());
489     if (dir == nullptr) {
490         return;
491     }
492     struct dirent *ptr;
493     std::string heapName = "";
494     while ((ptr = readdir(dir)) != nullptr) {
495         std::string fileName = ptr->d_name;
496         std::string::size_type idx = fileName.find("system");
497         if (idx != std::string::npos) {
498             heapName = fileName;
499             break;
500         }
501     }
502     closedir(dir);
503     dmaHeapFd_ = DmabufHeapOpen(heapName.c_str());
504 }
505 
~HardwareHeapFactory()506 HardwareHeapFactory::~HardwareHeapFactory()
507 {
508     DmabufHeapClose(dmaHeapFd_);
509 }
510 
GetInstance()511 HardwareHeapFactory &HardwareHeapFactory::GetInstance()
512 {
513     static HardwareHeapFactory hwHeapInstance;
514     return hwHeapInstance;
515 }
516 
GetHardwareHeapFd() const517 int32_t HardwareHeapFactory::GetHardwareHeapFd() const
518 {
519     return dmaHeapFd_;
520 }
521 
SetUpTestCase(void)522 void AVBufferFrameworkUnitTest::SetUpTestCase(void) {}
523 
TearDownTestCase(void)524 void AVBufferFrameworkUnitTest::TearDownTestCase(void) {}
525 
SetUp(void)526 void AVBufferFrameworkUnitTest::SetUp(void)
527 {
528     std::cout << "[SetUp]: SetUp!!!" << std::endl;
529     const ::testing::TestInfo *testInfo_ = ::testing::UnitTest::GetInstance()->current_test_info();
530     std::string testName = testInfo_->name();
531     std::cout << testName << std::endl;
532 
533     buffer_ = AVBufferMockFactory::CreateAVBuffer(MEMSIZE);
534     EXPECT_NE(nullptr, buffer_);
535 }
536 
TearDown(void)537 void AVBufferFrameworkUnitTest::TearDown(void)
538 {
539     std::cout << "[TearDown]: over!!!" << std::endl;
540 }
541 } // namespace AVBufferUT
542 } // namespace Media
543 } // namespace OHOS