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
21using namespace std;
22using namespace Hpackage;
23using namespace UpdatePatch;
24using namespace testing::ext;
25
26namespace {
27class TestCompressedImagePatch : public CompressedImagePatch {
28public:
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 &param, size_t &startOffset) override
35    {
36        return 0;
37    }
38
39    int32_t TestStartReadHeader(const PatchParam &param, PatchHeader &header, size_t &offset)
40    {
41        return StartReadHeader(param, header, offset);
42    }
43
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    }
49protected:
50    int32_t ReadHeader(const PatchParam &param, 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
62class CompressedImagePatchUnitTest : public testing::Test {
63public:
64    CompressedImagePatchUnitTest() {}
65    ~CompressedImagePatchUnitTest() {}
66
67    static void SetUpTestCase(void) {}
68    static void TearDownTestCase(void) {}
69    void SetUp() {}
70    void TearDown() {}
71    void TestBody() {}
72};
73
74HWTEST_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
89HWTEST_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
110HWTEST_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