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 "image_patch.h"
18 #include "diffpatch.h"
19 #include "unittest_comm.h"
20 
21 using namespace std;
22 using namespace Hpackage;
23 using namespace UpdatePatch;
24 using namespace testing::ext;
25 
26 namespace {
27 class TestCompressedImagePatch : public CompressedImagePatch {
28 public:
TestCompressedImagePatch(UpdatePatchWriterPtr writer,const std::vector<uint8_t> & bonusData)29     TestCompressedImagePatch(UpdatePatchWriterPtr writer, const std::vector<uint8_t> &bonusData)
30         : CompressedImagePatch(writer, bonusData) {}
31 
~TestCompressedImagePatch()32     ~TestCompressedImagePatch() override {}
33 
ApplyImagePatch(const PatchParam & param,size_t & startOffset)34     int32_t ApplyImagePatch(const PatchParam &param, size_t &startOffset) override
35     {
36         return 0;
37     }
38 
TestStartReadHeader(const PatchParam & param,PatchHeader & header,size_t & offset)39     int32_t TestStartReadHeader(const PatchParam &param, PatchHeader &header, size_t &offset)
40     {
41         return StartReadHeader(param, header, offset);
42     }
43 
TestDecompressData(PkgManager::PkgManagerPtr & pkgManager,PkgBuffer buffer,PkgManager::StreamPtr & stream,bool memory,size_t expandedLen)44     int32_t TestDecompressData(PkgManager::PkgManagerPtr &pkgManager, PkgBuffer buffer,
45     PkgManager::StreamPtr &stream, bool memory, size_t expandedLen)
46     {
47         return DecompressData(pkgManager, buffer, stream, memory, expandedLen);
48     }
49 protected:
ReadHeader(const PatchParam & param,PatchHeader & header,size_t & offset)50     int32_t ReadHeader(const PatchParam &param, PatchHeader &header, size_t &offset) override
51     {
52         return 0;
53     }
54 
GetFileInfo() const55     std::unique_ptr<FileInfo> GetFileInfo() const override
56     {
57         ZipFileInfo *fileInfo = new(std::nothrow) ZipFileInfo;
58         return std::unique_ptr<FileInfo>((FileInfo *)fileInfo);
59     }
60 };
61 
62 class CompressedImagePatchUnitTest : public testing::Test {
63 public:
CompressedImagePatchUnitTest()64     CompressedImagePatchUnitTest() {}
~CompressedImagePatchUnitTest()65     ~CompressedImagePatchUnitTest() {}
66 
SetUpTestCase(void)67     static void SetUpTestCase(void) {}
TearDownTestCase(void)68     static void TearDownTestCase(void) {}
SetUp()69     void SetUp() {}
TearDown()70     void TearDown() {}
TestBody()71     void TestBody() {}
72 };
73 
74 HWTEST_F(CompressedImagePatchUnitTest, TestStartReadHeader, TestSize.Level0)
75 {
76     UpdatePatchWriterPtr writer = nullptr;
77     const std::vector<uint8_t> bonusData;
78     TestCompressedImagePatch test(writer, bonusData);
79     PatchParam patchParam = {
80         reinterpret_cast<u_char*>(const_cast<char*>("xxx")), sizeof("xxx"),
81         reinterpret_cast<u_char*>(const_cast<char*>("xxx")), sizeof("xxx")
82     };
83     PatchHeader header = {0, 0, 0, 0, 0};
84     size_t offset = 0;
85     int32_t ret = test.TestStartReadHeader(patchParam, header, offset);
86     EXPECT_EQ(ret, 0);
87 }
88 
89 HWTEST_F(CompressedImagePatchUnitTest, TestDecompressData, TestSize.Level0)
90 {
91     UpdatePatchWriterPtr writer = nullptr;
92     const std::vector<uint8_t> bonusData;
93     TestCompressedImagePatch test(writer, bonusData);
94     PkgManager::PkgManagerPtr pkgManager = nullptr;
95     PkgBuffer buffer;
96     PkgManager::StreamPtr stream;
97     bool memory = false;
98     size_t expandedLen = 0;
99     int32_t ret = test.TestDecompressData(pkgManager, buffer, stream, memory, expandedLen);
100     EXPECT_EQ(ret, 0);
101     expandedLen = 1;
102     ret = test.TestDecompressData(pkgManager, buffer, stream, memory, expandedLen);
103     EXPECT_EQ(ret, -1);
104     pkgManager = PkgManager::CreatePackageInstance();
105     ret = test.TestDecompressData(pkgManager, buffer, stream, memory, expandedLen);
106     EXPECT_EQ(ret, -1);
107     PkgManager::ReleasePackageInstance(pkgManager);
108 }
109 
110 HWTEST_F(CompressedImagePatchUnitTest, TestApplyImagePatch, TestSize.Level0)
111 {
112     const std::vector<uint8_t> bonusData;
113     PatchParam patchParam = {
114         reinterpret_cast<u_char*>(const_cast<char*>("xxx")), sizeof("xxx"),
115         reinterpret_cast<u_char*>(const_cast<char*>("xxx")), sizeof("xxx")
116     };
117     UpdatePatchWriterPtr writer { nullptr };
118     std::unique_ptr<ImagePatch> imagePatch = std::make_unique<ZipImagePatch>(writer, bonusData);
119     size_t offset = 0;
120     int32_t ret = imagePatch->ApplyImagePatch(patchParam, offset);
121     EXPECT_EQ(ret, -1);
122 }
123 }
124