1 /*
2  * Copyright (c) 2024 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 <gmock/gmock.h>
17 #include <gtest/gtest.h>
18 
19 #include "b_error/b_error.h"
20 #include "file_ex.h"
21 #include "library_func_mock.h"
22 #include "test_manager.h"
23 #include "untar_file.cpp"
24 
25 
26 namespace OHOS::FileManagement::Backup {
27 using namespace std;
28 using namespace testing;
29 using namespace OHOS::AppFileService;
30 class UntarFileSupTest : public testing::Test {
31 public:
32     static void SetUpTestCase(void);
33     static void TearDownTestCase();
SetUp()34     void SetUp() override {};
TearDown()35     void TearDown() override {};
36     static inline shared_ptr<LibraryFuncMock> funcMock = nullptr;
37 };
38 
ClearCache()39 static void ClearCache()
40 {
41     UntarFile::GetInstance().rootPath_.clear();
42     UntarFile::GetInstance().tarFileSize_ = 0;
43     UntarFile::GetInstance().tarFileBlockCnt_ = 0;
44     UntarFile::GetInstance().pos_ = 0;
45     UntarFile::GetInstance().readCnt_ = 0;
46     if (UntarFile::GetInstance().tarFilePtr_ != nullptr) {
47         fclose(UntarFile::GetInstance().tarFilePtr_);
48         UntarFile::GetInstance().tarFilePtr_ = nullptr;
49     }
50     TarFile::GetInstance().fileCount_ = 0;
51     TarFile::GetInstance().tarMap_.clear();
52     TarFile::GetInstance().rootPath_.clear();
53     TarFile::GetInstance().packagePath_.clear();
54     TarFile::GetInstance().baseTarName_.clear();
55     TarFile::GetInstance().tarFileName_.clear();
56     TarFile::GetInstance().ioBuffer_.clear();
57     TarFile::GetInstance().currentTarName_.clear();
58     TarFile::GetInstance().currentTarFileSize_ = 0;
59     TarFile::GetInstance().tarFileCount_ = 0;
60     TarFile::GetInstance().currentFileName_.clear();
61     if (TarFile::GetInstance().currentTarFile_ != nullptr) {
62         fclose(TarFile::GetInstance().currentTarFile_);
63         TarFile::GetInstance().currentTarFile_ = nullptr;
64     }
65 }
66 
SetUpTestCase(void)67 void UntarFileSupTest::SetUpTestCase(void)
68 {
69     GTEST_LOG_(INFO) << "SetUpTestCase enter";
70     funcMock = make_shared<LibraryFuncMock>();
71     LibraryFuncMock::libraryFunc_ = funcMock;
72 }
73 
TearDownTestCase()74 void UntarFileSupTest::TearDownTestCase()
75 {
76     GTEST_LOG_(INFO) << "TearDownTestCase enter";
77     LibraryFuncMock::libraryFunc_ = nullptr;
78     funcMock = nullptr;
79     ClearCache();
80 }
81 
82 /**
83  * @tc.number: SUB_Untar_File_IsEmptyBlock_0100
84  * @tc.name: SUB_Untar_File_IsEmptyBlock_0100
85  * @tc.desc: 测试 IsEmptyBlock
86  * @tc.size: MEDIUM
87  * @tc.type: FUNC
88  * @tc.level Level 1
89  * @tc.require: I6F3GV
90  */
91 HWTEST_F(UntarFileSupTest, SUB_Untar_File_IsEmptyBlock_0100, testing::ext::TestSize.Level1)
92 {
93     GTEST_LOG_(INFO) << "UntarFileSupTest-begin SUB_Untar_File_IsEmptyBlock_0100";
94     try {
95         EXPECT_EQ(IsEmptyBlock(nullptr), true);
96         char buff[BLOCK_SIZE] = {0};
97         EXPECT_EQ(IsEmptyBlock(buff), true);
98     } catch (...) {
99         EXPECT_TRUE(false);
100         GTEST_LOG_(INFO) << "UntarFileSupTest-an exception occurred by IsEmptyBlock.";
101     }
102     GTEST_LOG_(INFO) << "UntarFileSupTest-end SUB_Untar_File_IsEmptyBlock_0100";
103 }
104 
105 /**
106  * @tc.number: SUB_Untar_File_ParseOctalStr_0100
107  * @tc.name: SUB_Untar_File_ParseOctalStr_0100
108  * @tc.desc: 测试 ParseOctalStr 接口
109  * @tc.size: MEDIUM
110  * @tc.type: FUNC
111  * @tc.level Level 1
112  * @tc.require: I6F3GV
113  */
114 HWTEST_F(UntarFileSupTest, SUB_Untar_File_ParseOctalStr_0100, testing::ext::TestSize.Level1)
115 {
116     GTEST_LOG_(INFO) << "UntarFileSupTest-begin SUB_Untar_File_ParseOctalStr_0100";
117     EXPECT_EQ(ParseOctalStr("0", 0), 0);
118     EXPECT_EQ(ParseOctalStr("1234", 0), 0);
119     EXPECT_EQ(ParseOctalStr("()-891234", 10), 668);
120     GTEST_LOG_(INFO) << "UntarFileSupTest-end SUB_Untar_File_ParseOctalStr_0100";
121 }
122 
123 /**
124  * @tc.number: SUB_Untar_File_GenRealPath_0100
125  * @tc.name: SUB_Untar_File_GenRealPath_0100
126  * @tc.desc: 测试 GenRealPath 接口
127  * @tc.size: MEDIUM
128  * @tc.type: FUNC
129  * @tc.level Level 1
130  * @tc.require: I6F3GV
131  */
132 HWTEST_F(UntarFileSupTest, SUB_Untar_File_GenRealPath_0100, testing::ext::TestSize.Level1)
133 {
134     GTEST_LOG_(INFO) << "UntarFileSupTest-begin SUB_Untar_File_GenRealPath_0100";
135     string rootPath = "";
136     string realName = "";
137     EXPECT_EQ(UntarFile::GetInstance().GenRealPath(rootPath, realName), "");
138 
139     rootPath = "rootPath";
140     EXPECT_EQ(UntarFile::GetInstance().GenRealPath(rootPath, realName), "");
141 
142     realName = "realName";
143     EXPECT_EQ(UntarFile::GetInstance().GenRealPath(rootPath, realName), "rootPath/realName");
144 
145     rootPath = "/rootPath/";
146     realName = "/realName";
147     EXPECT_EQ(UntarFile::GetInstance().GenRealPath(rootPath, realName), "rootPath/realName");
148     GTEST_LOG_(INFO) << "UntarFileSupTest-end SUB_Untar_File_GenRealPath_0100";
149 }
150 
151 /**
152  * @tc.number: SUB_Untar_File_ForceCreateDirectoryWithMode_0100
153  * @tc.name: SUB_Untar_File_ForceCreateDirectoryWithMode_0100
154  * @tc.desc: 测试 ForceCreateDirectoryWithMode 接口
155  * @tc.size: MEDIUM
156  * @tc.type: FUNC
157  * @tc.level Level 1
158  * @tc.require: I6F3GV
159  */
160 HWTEST_F(UntarFileSupTest, SUB_Untar_File_ForceCreateDirectoryWithMode_0100, testing::ext::TestSize.Level1)
161 {
162     GTEST_LOG_(INFO) << "UntarFileSupTest-begin SUB_Untar_File_ForceCreateDirectoryWithMode_0100";
163     string rootPath = "rootPath/realName";
164     EXPECT_CALL(*funcMock, access(_, _)).WillOnce(Return(1));
165     EXPECT_CALL(*funcMock, mkdir(_, _)).WillOnce(Return(1));
166     EXPECT_EQ(ForceCreateDirectoryWithMode(rootPath, S_IRWXU), false);
167 
168     EXPECT_CALL(*funcMock, access(_, _)).WillOnce(Return(0)).WillOnce(Return(1)).WillOnce(Return(0));
169     EXPECT_CALL(*funcMock, mkdir(_, _)).WillOnce(Return(0));
170     EXPECT_EQ(ForceCreateDirectoryWithMode(rootPath, S_IRWXU), true);
171 
172     EXPECT_CALL(*funcMock, access(_, _)).WillOnce(Return(0)).WillOnce(Return(1)).WillOnce(Return(1));
173     EXPECT_CALL(*funcMock, mkdir(_, _)).WillOnce(Return(0));
174     EXPECT_EQ(ForceCreateDirectoryWithMode(rootPath, S_IRWXU), false);
175     GTEST_LOG_(INFO) << "UntarFileSupTest-end SUB_Untar_File_ParseOctalStr_0100";
176 }
177 
178 /**
179  * @tc.number: SUB_Untar_File_CreateDir_0100
180  * @tc.name: SUB_Untar_File_CreateDir_0100
181  * @tc.desc: 测试 CreateDir 接口
182  * @tc.size: MEDIUM
183  * @tc.type: FUNC
184  * @tc.level Level 1
185  * @tc.require: I6F3GV
186  */
187 HWTEST_F(UntarFileSupTest, SUB_Untar_File_CreateDir_0100, testing::ext::TestSize.Level1)
188 {
189     GTEST_LOG_(INFO) << "UntarFileSupTest-begin SUB_Untar_File_CreateDir_0100";
190     string rootPath = "";
191     try {
192         UntarFile::GetInstance().CreateDir(rootPath, S_IRWXU);
193         rootPath = "rootPath/realName";
194         EXPECT_CALL(*funcMock, access(_, _)).WillOnce(Return(0));
195         UntarFile::GetInstance().CreateDir(rootPath, S_IRWXU);
196 
197         rootPath = "rootPath/realName";
198         EXPECT_CALL(*funcMock, access(_, _)).WillOnce(Return(1)).WillOnce(Return(0))
199             .WillOnce(Return(1)).WillOnce(Return(0));
200         EXPECT_CALL(*funcMock, mkdir(_, _)).WillOnce(Return(0));
201         UntarFile::GetInstance().CreateDir(rootPath, S_IRWXU);
202 
203         EXPECT_CALL(*funcMock, access(_, _)).WillOnce(Return(1)).WillOnce(Return(0))
204             .WillOnce(Return(1)).WillOnce(Return(1));
205         EXPECT_CALL(*funcMock, mkdir(_, _)).WillOnce(Return(0));
206         UntarFile::GetInstance().CreateDir(rootPath, S_IRWXU);
207     } catch (...) {
208         EXPECT_TRUE(false);
209         GTEST_LOG_(INFO) << "UntarFileSupTest-an exception occurred by CreateDir.";
210     }
211     GTEST_LOG_(INFO) << "UntarFileSupTest-end SUB_Untar_File_CreateDir_0100";
212 }
213 
214 /**
215  * @tc.number: SUB_Untar_File_ParseFileByTypeFlag_0100
216  * @tc.name: SUB_Untar_File_ParseFileByTypeFlag_0100
217  * @tc.desc: 测试 ParseFileByTypeFlag 接口
218  * @tc.size: MEDIUM
219  * @tc.type: FUNC
220  * @tc.level Level 1
221  * @tc.require: I6F3GV
222  */
223 HWTEST_F(UntarFileSupTest, SUB_Untar_File_ParseFileByTypeFlag_0100, testing::ext::TestSize.Level1)
224 {
225     GTEST_LOG_(INFO) << "UntarFileSupTest-begin SUB_Untar_File_CreateDir_0100";
226     FileStatInfo info;
227     info.fullPath = "realName";
228     UntarFile::GetInstance().rootPath_ = "rootPath";
229     try {
230         UntarFile::GetInstance().ParseFileByTypeFlag(SYMTYPE, info);
231 
232         EXPECT_CALL(*funcMock, access(_, _)).WillOnce(Return(1)).WillOnce(Return(0))
233             .WillOnce(Return(1)).WillOnce(Return(0));
234         EXPECT_CALL(*funcMock, mkdir(_, _)).WillOnce(Return(0));
235         UntarFile::GetInstance().ParseFileByTypeFlag(DIRTYPE, info);
236         EXPECT_EQ(info.fullPath, "rootPath/realName");
237 
238         EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(0));
239         UntarFile::GetInstance().ParseFileByTypeFlag('6', info);
240     } catch (...) {
241         EXPECT_TRUE(false);
242         GTEST_LOG_(INFO) << "UntarFileSupTest-an exception occurred by ParseFileByTypeFlag.";
243     }
244     GTEST_LOG_(INFO) << "UntarFileSupTest-end SUB_Untar_File_CreateDir_0100";
245 }
246 
247 /**
248  * @tc.number: SUB_Untar_File_IsValidTarBlock_0100
249  * @tc.name: SUB_Untar_File_IsValidTarBlock_0100
250  * @tc.desc: 测试 IsValidTarBlock 接口
251  * @tc.size: MEDIUM
252  * @tc.type: FUNC
253  * @tc.level Level 1
254  * @tc.require: I6F3GV
255  */
256 HWTEST_F(UntarFileSupTest, SUB_Untar_File_IsValidTarBlock_0100, testing::ext::TestSize.Level1)
257 {
258     GTEST_LOG_(INFO) << "UntarFileSupTest-begin SUB_Untar_File_IsValidTarBlock_0100";
259     TarHeader header { .magic = "test" };
260     try {
261         EXPECT_EQ(UntarFile::GetInstance().IsValidTarBlock(header), false);
262         EXPECT_TRUE(true);
263     } catch (...) {
264         EXPECT_TRUE(false);
265         GTEST_LOG_(INFO) << "UntarFileSupTest-an exception occurred by IsValidTarBlock.";
266     }
267     GTEST_LOG_(INFO) << "UntarFileSupTest-end SUB_Untar_File_IsValidTarBlock_0100";
268 }
269 } // namespace OHOS::FileManagement::Backup