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
32 ~TestCompressedImagePatch() override {}
33
34 int32_t ApplyImagePatch(const PatchParam ¶m, size_t &startOffset) override
35 {
36 return 0;
37 }
38
TestStartReadHeader(const PatchParam ¶m, PatchHeader &header, size_t &offset)39 int32_t TestStartReadHeader(const PatchParam ¶m, 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:
50 int32_t ReadHeader(const PatchParam ¶m, PatchHeader &header, size_t &offset) override
51 {
52 return 0;
53 }
54
55 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
HWTEST_F(CompressedImagePatchUnitTest, TestStartReadHeader, TestSize.Level0)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
HWTEST_F(CompressedImagePatchUnitTest, TestDecompressData, TestSize.Level0)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
HWTEST_F(CompressedImagePatchUnitTest, TestApplyImagePatch, TestSize.Level0)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