1 /*
2  * Copyright (c) 2022-2022 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 <cstdlib>
17 #include <memory>
18 #include <string>
19 #include "gtest/gtest.h"
20 #define private public
21 #define protected public
22 #include "pipeline/filters/demux/data_packer.h"
23 
24 using namespace testing::ext;
25 
26 namespace OHOS {
27 namespace Media {
28 namespace Test {
29 using namespace OHOS::Media::Plugin;
30 
31 class TestDataPacker : public ::testing::Test {
32 public:
33     std::shared_ptr<DataPacker> dataPacker;
SetUp()34     void SetUp() override
35     {
36         dataPacker = std::make_shared<DataPacker>();
37     }
38 
TearDown()39     void TearDown() override
40     {
41     }
42 };
43 
CreateBuffer(size_t size,uint64_t offset=0)44 AVBufferPtr CreateBuffer(size_t size, uint64_t offset = 0)
45 {
46     const uint8_t* data = (uint8_t*)"1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
47     auto buffer = std::make_shared<AVBuffer>();
48     buffer->AllocMemory(nullptr, size);
49     buffer->GetMemory()->Write(data + offset, size);
50     return buffer;
51 }
52 
CreateEmptyBuffer(size_t size)53 AVBufferPtr CreateEmptyBuffer(size_t size)
54 {
55     auto buffer = std::make_shared<AVBuffer>();
56     buffer->AllocMemory(nullptr, size);
57     buffer->GetMemory()->Write((uint8_t*)"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0", size);
58     return buffer;
59 }
60 
61 HWTEST_F(TestDataPacker, can_push_one_buffer_to_datapacker, TestSize.Level1)
62 {
63     auto bufferPtr = CreateBuffer(10);
64     dataPacker->PushData(bufferPtr, 0);
65     ASSERT_STREQ("DataPacker (offset 0, size 10, buffer count 1)", dataPacker->ToString().c_str());
66 }
67 
68 HWTEST_F(TestDataPacker, can_push_two_buffers_to_datapacker, TestSize.Level1)
69 {
70     auto bufferPtr = CreateBuffer(10);
71     dataPacker->PushData(bufferPtr, 0);
72     auto bufferPtr2 = CreateBuffer(4, 10);
73     dataPacker->PushData(bufferPtr2, 10);
74     ASSERT_STREQ("DataPacker (offset 0, size 14, buffer count 2)", dataPacker->ToString().c_str());
75 }
76 
77 HWTEST_F(TestDataPacker, should_return_true_if_check_range_in_datapacker, TestSize.Level1)
78 {
79     auto bufferPtr = CreateBuffer(10);
80     dataPacker->PushData(bufferPtr, 0);
81     uint64_t curOffset = 0;
82     ASSERT_TRUE(dataPacker->IsDataAvailable(3, 2, curOffset));
83     ASSERT_EQ(curOffset, 10);
84 }
85 
86 HWTEST_F(TestDataPacker, should_return_false_if_check_range_not_in_datapacker, TestSize.Level1)
87 {
88     auto bufferPtr = CreateBuffer(10);
89     dataPacker->PushData(bufferPtr, 0);
90     uint64_t curOffset = 0;
91     ASSERT_FALSE(dataPacker->IsDataAvailable(11, 2, curOffset));
92 }
93 
94 HWTEST_F(TestDataPacker, should_update_offset_to_get_range_offset_if_start_not_in_datapacker, TestSize.Level1)
95 {
96     auto bufferPtr = CreateBuffer(10);
97     dataPacker->PushData(bufferPtr, 0);
98     uint64_t curOffset = 0;
99     ASSERT_FALSE(dataPacker->IsDataAvailable(11, 2, curOffset));
100     ASSERT_EQ(curOffset, 11);
101 }
102 
103 HWTEST_F(TestDataPacker, should_update_offset_to_datapacker_offset_end_if_start_in_datapacker, TestSize.Level1)
104 {
105     auto bufferPtr = CreateBuffer(10);
106     dataPacker->PushData(bufferPtr, 0);
107     uint64_t curOffset = 0;
108     ASSERT_FALSE(dataPacker->IsDataAvailable(8, 10, curOffset));
109     ASSERT_EQ(curOffset, 10);
110 }
111 
112 HWTEST_F(TestDataPacker, can_get_data_in_the_middle_of_one_buffer, TestSize.Level1)
113 {
114     auto bufferPtr = CreateBuffer(10);
115     dataPacker->PushData(bufferPtr, 0);
116     ASSERT_STREQ("DataPacker (offset 0, size 10, buffer count 1)", dataPacker->ToString().c_str());
117     uint64_t curOffset = 0;
118     ASSERT_TRUE(dataPacker->IsDataAvailable(3, 2, curOffset));
119     ASSERT_EQ(curOffset, 10);
120     auto bufferOut = CreateEmptyBuffer(3);
121     dataPacker->GetRange(3, 2, bufferOut);
122     ASSERT_STREQ("45", (const char *)(bufferOut->GetMemory()->GetReadOnlyData()));
123 }
124 
125 HWTEST_F(TestDataPacker, remove_old_data_after_second_get_range, TestSize.Level1)
126 {
127     auto bufferPtr = CreateBuffer(10);
128     dataPacker->PushData(bufferPtr, 0);
129     ASSERT_STREQ("DataPacker (offset 0, size 10, buffer count 1)", dataPacker->ToString().c_str());
130     uint64_t curOffset = 0;
131     ASSERT_TRUE(dataPacker->IsDataAvailable(3, 2, curOffset));
132     ASSERT_EQ(curOffset, 10);
133     auto bufferOut = CreateEmptyBuffer(5);
134     dataPacker->GetRange(3, 4, bufferOut);
135     bufferOut->GetMemory()->UpdateDataSize(0);
136     dataPacker->GetRange(5, 2, bufferOut);
137     ASSERT_STREQ("DataPacker (offset 5, size 5, buffer count 1)", dataPacker->ToString().c_str());
138 }
139 
140 HWTEST_F(TestDataPacker, remove_old_data_after_second_get_range_when_two_buffers_in_datapacker, TestSize.Level1)
141 {
142     auto bufferPtr = CreateBuffer(10);
143     dataPacker->PushData(bufferPtr, 0);
144     auto bufferPtr2 = CreateBuffer(4, 10);
145     dataPacker->PushData(bufferPtr2, 10);
146     ASSERT_STREQ("DataPacker (offset 0, size 14, buffer count 2)", dataPacker->ToString().c_str());
147 
148     auto bufferOut = CreateEmptyBuffer(5);
149     dataPacker->GetRange(3, 4, bufferOut);
150     ASSERT_STREQ("DataPacker (offset 0, size 14, buffer count 2)", dataPacker->ToString().c_str());
151 
152     bufferOut->GetMemory()->UpdateDataSize(0);
153     dataPacker->GetRange(11, 2, bufferOut);
154     ASSERT_STREQ("DataPacker (offset 11, size 3, buffer count 1)", dataPacker->ToString().c_str());
155 }
156 HWTEST_F(TestDataPacker, can_get_data_from_two_buffers, TestSize.Level1)
157 {
158     auto bufferPtr = CreateBuffer(10);
159     dataPacker->PushData(bufferPtr, 0);
160     uint64_t curOffset = 0;
161     ASSERT_FALSE(dataPacker->IsDataAvailable(0, 15, curOffset));
162     ASSERT_EQ(curOffset, 10);
163     auto bufferPtr2 = CreateBuffer(10, curOffset);
164     dataPacker->PushData(bufferPtr2, curOffset);
165     auto bufferOut = CreateEmptyBuffer(16);
166     ASSERT_TRUE(dataPacker->GetRange(0, 15, bufferOut));
167     ASSERT_EQ(15, bufferOut->GetMemory()->GetSize());
168     ASSERT_STREQ("1234567890abcde", (const char*)(bufferOut->GetMemory()->GetReadOnlyData()));
169 }
170 } // namespace Test
171 } // namespace Media
172 } // namespace OHOS