• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2021 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 "bzip2_adapter.h"
18 #include "diffpatch.h"
19 #include "lz4_adapter.h"
20 #include "unittest_comm.h"
21 #include "update_patch.h"
22 #include "zip_adapter.h"
23 
24 using namespace std;
25 using namespace Hpackage;
26 using namespace UpdatePatch;
27 using namespace testing::ext;
28 
29 namespace {
30 #define LZ4_BLOCK_SIZE(blockId) (1 << (8 + (2 * (blockId))))
31 
32 class TestPatchWriter : public UpdatePatchWriter {
33 public:
TestPatchWriter(std::vector<uint8_t> & buffer)34     explicit TestPatchWriter(std::vector<uint8_t> &buffer) : UpdatePatchWriter(), buffer_(buffer) {}
~TestPatchWriter()35     ~TestPatchWriter() override {}
36 
Init()37     int32_t Init() override
38     {
39         return 0;
40     };
Finish()41     int32_t Finish() override
42     {
43         return 0;
44     };
Write(size_t start,const BlockBuffer & data,size_t len)45     int32_t Write(size_t start, const BlockBuffer &data, size_t len) override
46     {
47         if (len == 0) {
48             return 0;
49         }
50         bufferSize += len;
51         if ((start + bufferSize) > buffer_.size()) {
52             buffer_.resize(IGMDIFF_LIMIT_UNIT * ((start + bufferSize) / IGMDIFF_LIMIT_UNIT + 1));
53         }
54         return memcpy_s(buffer_.data() + start, buffer_.size(), data.buffer, len);
55     }
56 private:
57     size_t bufferSize {0};
58     std::vector<uint8_t> &buffer_;
59 };
60 
61 class BZip2AdapterUnitTest : public testing::Test {
62 public:
BZip2AdapterUnitTest()63     BZip2AdapterUnitTest() {}
~BZip2AdapterUnitTest()64     ~BZip2AdapterUnitTest() {}
65 
SetUpTestCase(void)66     static void SetUpTestCase(void) {}
TearDownTestCase(void)67     static void TearDownTestCase(void) {}
SetUp()68     void SetUp() {}
TearDown()69     void TearDown() {}
TestBody()70     void TestBody() {}
71 public:
BZip2AdapterBufferTest() const72     int BZip2AdapterBufferTest() const
73     {
74         MemMapInfo data {};
75         std::string fileName = TEST_PATH_FROM;
76         fileName += "test_script.us";
77         int32_t ret = PatchMapFile(fileName, data);
78         EXPECT_EQ(0, ret);
79 
80         std::vector<uint8_t> compressedData;
81         BZipBuffer2Adapter adapter(compressedData, 0);
82         adapter.Open();
83         // compress data 1
84         BlockBuffer srcData = {data.memory, data.length};
85         ret = adapter.WriteData(srcData);
86         EXPECT_EQ(0, ret);
87         size_t compressedData1 = 0;
88         ret = adapter.FlushData(compressedData1);
89         EXPECT_EQ(0, ret);
90         adapter.Close();
91 
92         // compress data 2
93         BZipBuffer2Adapter adapter2(compressedData, compressedData1);
94         adapter2.Open();
95         ret = adapter2.WriteData(srcData);
96         EXPECT_EQ(0, ret);
97         size_t compressedData2 = 0;
98         ret = adapter2.FlushData(compressedData2);
99         EXPECT_EQ(0, ret);
100         adapter2.Close();
101 
102         PATCH_LOGI("compressedData size %zu %zu %zu", compressedData.size(), compressedData1, compressedData2);
103         // decompress data 1
104         BlockBuffer compressedInfo = {compressedData.data(), compressedData.size()};
105         BZip2BufferReadAdapter readAdapter(0, compressedData1, compressedInfo);
106         readAdapter.Open();
107 
108         std::vector<uint8_t> dataArray(data.length);
109         BlockBuffer data1 = {dataArray.data(), data.length};
110         ret = readAdapter.ReadData(data1);
111         EXPECT_EQ(0, ret);
112         EXPECT_EQ(0, memcmp(data1.buffer, data.memory, data1.length));
113 
114         // decompress data 2
115         BZip2BufferReadAdapter readAdapter2(compressedData1, compressedData2, compressedInfo);
116         readAdapter2.Open();
117         ret = readAdapter2.ReadData(data1);
118         EXPECT_EQ(0, ret);
119         EXPECT_EQ(0, memcmp(data1.buffer, data.memory, data1.length));
120 
121         adapter.Close();
122         readAdapter.Close();
123         return 0;
124     }
125 
BZip2AdapterAddMoreTest() const126     int BZip2AdapterAddMoreTest() const
127     {
128         MemMapInfo data {};
129         std::string fileName = TEST_PATH_FROM;
130         fileName += "test_script.us";
131         int32_t ret = PatchMapFile(fileName, data);
132         EXPECT_EQ(0, ret);
133 
134         std::vector<uint8_t> compressedData;
135         BZipBuffer2Adapter adapter(compressedData, 0);
136         adapter.Open();
137         // compress data 1
138         BlockBuffer srcData = {data.memory, data.length};
139         ret = adapter.WriteData(srcData);
140         EXPECT_EQ(0, ret);
141         // compress data 2
142         ret = adapter.WriteData(srcData);
143         EXPECT_EQ(0, ret);
144         // compress data 3
145         ret = adapter.WriteData(srcData);
146         EXPECT_EQ(0, ret);
147         size_t compressedData1 = 0;
148         ret = adapter.FlushData(compressedData1);
149         EXPECT_EQ(0, ret);
150         adapter.Close();
151 
152         PATCH_LOGI("compressedData size %zu %zu", compressedData.size(), compressedData1);
153 
154         BlockBuffer compressedInfo = {compressedData.data(), compressedData.size()};
155         BZip2BufferReadAdapter readAdapter(0, compressedData1, compressedInfo);
156         readAdapter.Open();
157 
158         // decompress data 1
159         std::vector<uint8_t> dataArray(data.length);
160         BlockBuffer data1 = {dataArray.data(), data.length};
161         ret = readAdapter.ReadData(data1);
162         EXPECT_EQ(0, ret);
163         EXPECT_EQ(0, memcmp(data1.buffer, data.memory, data1.length));
164 
165         // decompress data 2
166         ret = readAdapter.ReadData(data1);
167         EXPECT_EQ(0, ret);
168         EXPECT_EQ(0, memcmp(data1.buffer, data.memory, data1.length));
169 
170         // decompress data 3
171         ret = readAdapter.ReadData(data1);
172         EXPECT_EQ(0, ret);
173         EXPECT_EQ(0, memcmp(data1.buffer, data.memory, data1.length));
174 
175         adapter.Close();
176         readAdapter.Close();
177         return 0;
178     }
179 
CompressData(Hpackage::PkgManager::FileInfoPtr info,const BlockBuffer & buffer,std::vector<uint8_t> & outData,size_t & bufferSize)180     int32_t CompressData(Hpackage::PkgManager::FileInfoPtr info,
181         const BlockBuffer &buffer, std::vector<uint8_t> &outData, size_t &bufferSize)
182     {
183         Hpackage::PkgManager *pkgManager = Hpackage::PkgManager::GetPackageInstance();
184         PATCH_CHECK(pkgManager != nullptr, return -1, "Can not get manager ");
185         Hpackage::PkgManager::StreamPtr stream1 = nullptr;
186         pkgManager->CreatePkgStream(stream1, "gzip", [&outData, &bufferSize](const PkgBuffer &data,
187             size_t size, size_t start, bool isFinish, const void *context) ->int {
188                 if (isFinish) {
189                     return 0;
190                 }
191                 bufferSize += size;
192                 if ((start + bufferSize) > outData.size()) {
193                     outData.resize(IGMDIFF_LIMIT_UNIT * ((start + bufferSize) / IGMDIFF_LIMIT_UNIT + 1));
194                 }
195                 return memcpy_s(outData.data() + start, outData.size(), data.buffer, size);
196             }, nullptr);
197         int32_t ret = pkgManager->CompressBuffer(info, {buffer.buffer, buffer.length}, stream1);
198         PATCH_CHECK(ret == 0, return -1, "Can not Compress buff ");
199         PATCH_DEBUG("UpdateDiff::MakePatch totalSize: %zu", bufferSize);
200         return 0;
201     }
202 
DeflateAdapterTest(const std::string & fileName,Hpackage::PkgManager::FileInfoPtr info)203     int DeflateAdapterTest(const std::string &fileName, Hpackage::PkgManager::FileInfoPtr info)
204     {
205         std::vector<uint8_t> outData;
206         size_t dataSize = 0;
207         std::unique_ptr<TestPatchWriter> testPatchWriter(new TestPatchWriter(outData));
208         PATCH_CHECK(testPatchWriter != nullptr, return -1, "Failed to create data writer");
209 
210         MemMapInfo memInfo {};
211         int32_t ret = PatchMapFile(TEST_PATH_FROM + fileName, memInfo);
212         PATCH_CHECK(ret == 0, return -1, "Failed to map file");
213 
214         //
215         std::vector<uint8_t> outData1;
216         size_t dataSize1 = 0;
217         ret = CompressData(info, {memInfo.memory, memInfo.length}, outData1, dataSize1);
218         PATCH_CHECK(ret == 0, return -1, "Failed to compress file");
219 
220         info->unpackedSize = memInfo.length;
221 
222         std::unique_ptr<DeflateAdapter> deflateAdapter;
223         if (info->packMethod == PKG_COMPRESS_METHOD_ZIP) {
224             deflateAdapter.reset(new ZipAdapter(testPatchWriter.get(), 0, info));
225         } else if (info->packMethod == PKG_COMPRESS_METHOD_LZ4) {
226             deflateAdapter.reset(new Lz4FrameAdapter(testPatchWriter.get(), 0, info));
227         } else if (info->packMethod == PKG_COMPRESS_METHOD_LZ4_BLOCK) {
228             deflateAdapter.reset(new Lz4BlockAdapter(testPatchWriter.get(), 0, info));
229         }
230         PATCH_CHECK(deflateAdapter != nullptr, return -1, "Failed to create deflate adapter");
231         deflateAdapter->Open();
232 
233         size_t offset = 0;
234         while (offset < memInfo.length) {
235             size_t writeSize = (memInfo.length > (offset + DeflateAdapter::BUFFER_SIZE)) ?
236                 DeflateAdapter::BUFFER_SIZE : (memInfo.length - offset);
237             BlockBuffer data = {memInfo.memory + offset, writeSize};
238             ret = deflateAdapter->WriteData(data);
239             PATCH_CHECK(ret == 0, return -1, "Failed to compress data");
240             offset += writeSize;
241         }
242         deflateAdapter->FlushData(dataSize);
243 
244         PATCH_LOGI("data size %zu %zu", dataSize, dataSize1);
245 
246         // compare
247         if (dataSize == dataSize1 && memcmp(outData.data(), outData1.data(), dataSize1) == 0) {
248             return 0;
249         }
250         return 1;
251     }
252 };
253 
254 HWTEST_F(BZip2AdapterUnitTest, BZip2AdapterBufferTest, TestSize.Level1)
255 {
256     BZip2AdapterUnitTest test;
257     EXPECT_EQ(0, test.BZip2AdapterBufferTest());
258 }
259 
260 HWTEST_F(BZip2AdapterUnitTest, BZip2AdapterAddMoreTest, TestSize.Level1)
261 {
262     BZip2AdapterUnitTest test;
263     EXPECT_EQ(0, test.BZip2AdapterAddMoreTest());
264 }
265 
266 HWTEST_F(BZip2AdapterUnitTest, DeflateAdapterTestForZip, TestSize.Level1)
267 {
268     ZipFileInfo zipInfo {};
269     zipInfo.fileInfo.packMethod = PKG_COMPRESS_METHOD_ZIP;
270     zipInfo.method = 8;
271     zipInfo.level = 6;
272     zipInfo.windowBits = -15;
273     zipInfo.memLevel = 8;
274     zipInfo.strategy = 0;
275     BZip2AdapterUnitTest test;
276     EXPECT_EQ(0, test.DeflateAdapterTest("../diffpatch/patchtest.new", &zipInfo.fileInfo));
277 }
278 
279 HWTEST_F(BZip2AdapterUnitTest, DeflateAdapterTestForLz4, TestSize.Level1)
280 {
281     Lz4FileInfo lz4Info {};
282     lz4Info.fileInfo.packMethod = PKG_COMPRESS_METHOD_LZ4;
283     lz4Info.compressionLevel = 2;
284     lz4Info.blockIndependence = 0;
285     lz4Info.contentChecksumFlag = 0;
286     lz4Info.blockSizeID = 0;
287     BZip2AdapterUnitTest test;
288     EXPECT_EQ(0, test.DeflateAdapterTest("../diffpatch/patchtest.test", &lz4Info.fileInfo));
289 }
290 
291 HWTEST_F(BZip2AdapterUnitTest, DeflateAdapterTestForLz4_2, TestSize.Level1)
292 {
293     Lz4FileInfo lz4Info {};
294     lz4Info.fileInfo.packMethod = PKG_COMPRESS_METHOD_LZ4;
295     lz4Info.compressionLevel = 2;
296     lz4Info.blockIndependence = 0;
297     lz4Info.contentChecksumFlag = 0;
298     lz4Info.blockSizeID = 7;
299     BZip2AdapterUnitTest test;
300     EXPECT_EQ(0, test.DeflateAdapterTest("../diffpatch/patchtest.test", &lz4Info.fileInfo));
301 }
302 
303 HWTEST_F(BZip2AdapterUnitTest, DeflateAdapterTestForLz4_3, TestSize.Level1)
304 {
305     Lz4FileInfo lz4Info {};
306     lz4Info.fileInfo.packMethod = PKG_COMPRESS_METHOD_LZ4;
307     lz4Info.compressionLevel = 2;
308     lz4Info.blockIndependence = 0;
309     lz4Info.contentChecksumFlag = 0;
310     lz4Info.blockSizeID = 4;
311     BZip2AdapterUnitTest test;
312     EXPECT_EQ(0, test.DeflateAdapterTest("../diffpatch/patchtest.test", &lz4Info.fileInfo));
313 }
314 
315 HWTEST_F(BZip2AdapterUnitTest, DeflateAdapterTestForLz4_4, TestSize.Level1)
316 {
317     Lz4FileInfo lz4Info {};
318     lz4Info.fileInfo.packMethod = PKG_COMPRESS_METHOD_LZ4;
319     lz4Info.compressionLevel = 2;
320     lz4Info.blockIndependence = 0;
321     lz4Info.contentChecksumFlag = 0;
322     lz4Info.blockSizeID = 5;
323     BZip2AdapterUnitTest test;
324     EXPECT_EQ(0, test.DeflateAdapterTest("../diffpatch/patchtest.test", &lz4Info.fileInfo));
325 }
326 
327 HWTEST_F(BZip2AdapterUnitTest, DeflateAdapterTestForLz4_5, TestSize.Level1)
328 {
329     Lz4FileInfo lz4Info {};
330     lz4Info.fileInfo.packMethod = PKG_COMPRESS_METHOD_LZ4;
331     lz4Info.compressionLevel = 2;
332     lz4Info.blockIndependence = 0;
333     lz4Info.contentChecksumFlag = 0;
334     lz4Info.blockSizeID = 5;
335     lz4Info.autoFlush = 0;
336     BZip2AdapterUnitTest test;
337     EXPECT_EQ(0, test.DeflateAdapterTest("../diffpatch/patchtest.test", &lz4Info.fileInfo));
338 }
339 
340 HWTEST_F(BZip2AdapterUnitTest, DeflateAdapterTestForLz4Block, TestSize.Level1)
341 {
342     Lz4FileInfo lz4Info {};
343     lz4Info.fileInfo.packMethod = PKG_COMPRESS_METHOD_LZ4_BLOCK;
344     lz4Info.compressionLevel = 2;
345     lz4Info.blockIndependence = 1;
346     lz4Info.contentChecksumFlag = 1;
347     lz4Info.blockSizeID = 5;
348     BZip2AdapterUnitTest test;
349     EXPECT_EQ(0, test.DeflateAdapterTest("../diffpatch/patchtest.test", &lz4Info.fileInfo));
350 }
351 
352 HWTEST_F(BZip2AdapterUnitTest, DeflateAdapterTestForLz4Block_2, TestSize.Level1)
353 {
354     Lz4FileInfo lz4Info {};
355     lz4Info.fileInfo.packMethod = PKG_COMPRESS_METHOD_LZ4_BLOCK;
356     lz4Info.compressionLevel = 5;
357     lz4Info.blockIndependence = 1;
358     lz4Info.contentChecksumFlag = 1;
359     lz4Info.blockSizeID = 5;
360     BZip2AdapterUnitTest test;
361     EXPECT_EQ(0, test.DeflateAdapterTest("../diffpatch/patchtest.test", &lz4Info.fileInfo));
362 }
363 
364 HWTEST_F(BZip2AdapterUnitTest, DeflateAdapterTestForLz4Block_3, TestSize.Level1)
365 {
366     Lz4FileInfo lz4Info {};
367     lz4Info.fileInfo.packMethod = PKG_COMPRESS_METHOD_LZ4_BLOCK;
368     lz4Info.compressionLevel = 5;
369     lz4Info.blockIndependence = 1;
370     lz4Info.contentChecksumFlag = 1;
371     lz4Info.blockSizeID = 0;
372     BZip2AdapterUnitTest test;
373     EXPECT_EQ(0, test.DeflateAdapterTest("../diffpatch/patchtest.test", &lz4Info.fileInfo));
374 }
375 
376 HWTEST_F(BZip2AdapterUnitTest, DeflateAdapterTestForLz4Block_4, TestSize.Level1)
377 {
378     DeflateAdapter adapterTest;
379     BlockBuffer srcTestData;
380     size_t offTest = 0;
381     adapterTest.Open();
382     adapterTest.WriteData(srcTestData);
383     adapterTest.FlushData(offTest);
384 }
385 }
386