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
27using namespace std;
28using namespace testing::ext;
29
30namespace OHOS {
31namespace Media {
32namespace AVBufferUT {
33void AVBufferInnerUnitTest::SetUpTestCase(void)
34{
35    std::cout << "[SetUpTestCase]: SetUp!!!" << std::endl;
36}
37
38void AVBufferInnerUnitTest::TearDownTestCase(void)
39{
40    std::cout << "[TearDownTestCase]: over!!!" << std::endl;
41}
42
43void 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
61void 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
75void 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
90void 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
105void 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
122void 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
132void 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
142void 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
154void 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
164void 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
174void 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
184void 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
194void 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
207void 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
218void 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
228void 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
238void 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
247void 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
258void AVBufferInnerUnitTest::CreateLocalNullMem()
259{
260    parcel_ = std::make_shared<MessageParcel>();
261    // create remote
262    remoteBuffer_ = AVBuffer::CreateAVBuffer();
263    ASSERT_NE(nullptr, remoteBuffer_);
264}
265
266void 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
282void 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
306void 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
347void 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
381void 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
410void 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
436void 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
462void 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
485HardwareHeapFactory::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
506HardwareHeapFactory::~HardwareHeapFactory()
507{
508    DmabufHeapClose(dmaHeapFd_);
509}
510
511HardwareHeapFactory &HardwareHeapFactory::GetInstance()
512{
513    static HardwareHeapFactory hwHeapInstance;
514    return hwHeapInstance;
515}
516
517int32_t HardwareHeapFactory::GetHardwareHeapFd() const
518{
519    return dmaHeapFd_;
520}
521
522void AVBufferFrameworkUnitTest::SetUpTestCase(void) {}
523
524void AVBufferFrameworkUnitTest::TearDownTestCase(void) {}
525
526void 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
537void AVBufferFrameworkUnitTest::TearDown(void)
538{
539    std::cout << "[TearDown]: over!!!" << std::endl;
540}
541} // namespace AVBufferUT
542} // namespace Media
543} // namespace OHOS