1 /*
2 * Copyright (c) 2024-2025 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 <utime.h>
20
21 #include "b_anony/b_anony.h"
22 #include "b_error/b_error.h"
23 #include "b_filesystem/b_dir.h"
24 #include "directory_ex.h"
25 #include "file_ex.h"
26 #include "filemgmt_libhilog.h"
27 #include "library_func_mock.h"
28 #include "securec.h"
29 #include "test_manager.h"
30 #include "untar_file.h"
31
32 #include "library_func_define.h"
33 #include "untar_file.cpp"
34 #include "library_func_undef.h"
35
36 namespace OHOS::FileManagement::Backup {
37 using namespace std;
38 using namespace testing;
39 using namespace OHOS::AppFileService;
40 class UntarFileSupTest : public testing::Test {
41 public:
42 static void SetUpTestCase(void);
43 static void TearDownTestCase();
SetUp()44 void SetUp() override {};
TearDown()45 void TearDown() override {};
46 static inline shared_ptr<LibraryFuncMock> funcMock = nullptr;
47 };
48
ClearCache()49 static void ClearCache()
50 {
51 UntarFile::GetInstance().rootPath_.clear();
52 UntarFile::GetInstance().tarFileSize_ = 0;
53 UntarFile::GetInstance().tarFileBlockCnt_ = 0;
54 UntarFile::GetInstance().pos_ = 0;
55 UntarFile::GetInstance().readCnt_ = 0;
56 if (UntarFile::GetInstance().tarFilePtr_ != nullptr) {
57 fclose(UntarFile::GetInstance().tarFilePtr_);
58 UntarFile::GetInstance().tarFilePtr_ = nullptr;
59 }
60 TarFile::GetInstance().fileCount_ = 0;
61 TarFile::GetInstance().tarMap_.clear();
62 TarFile::GetInstance().rootPath_.clear();
63 TarFile::GetInstance().packagePath_.clear();
64 TarFile::GetInstance().baseTarName_.clear();
65 TarFile::GetInstance().tarFileName_.clear();
66 TarFile::GetInstance().ioBuffer_.clear();
67 TarFile::GetInstance().currentTarName_.clear();
68 TarFile::GetInstance().currentTarFileSize_ = 0;
69 TarFile::GetInstance().tarFileCount_ = 0;
70 TarFile::GetInstance().currentFileName_.clear();
71 if (TarFile::GetInstance().currentTarFile_ != nullptr) {
72 fclose(TarFile::GetInstance().currentTarFile_);
73 TarFile::GetInstance().currentTarFile_ = nullptr;
74 }
75 }
76
SetUpTestCase(void)77 void UntarFileSupTest::SetUpTestCase(void)
78 {
79 GTEST_LOG_(INFO) << "SetUpTestCase enter";
80 funcMock = make_shared<LibraryFuncMock>();
81 LibraryFuncMock::libraryFunc_ = funcMock;
82 }
83
TearDownTestCase()84 void UntarFileSupTest::TearDownTestCase()
85 {
86 GTEST_LOG_(INFO) << "TearDownTestCase enter";
87 LibraryFuncMock::libraryFunc_ = nullptr;
88 funcMock = nullptr;
89 ClearCache();
90 }
91
92 /**
93 * @tc.number: SUB_Untar_File_IsEmptyBlock_0100
94 * @tc.name: SUB_Untar_File_IsEmptyBlock_0100
95 * @tc.desc: 测试 IsEmptyBlock
96 * @tc.size: MEDIUM
97 * @tc.type: FUNC
98 * @tc.level Level 1
99 * @tc.require: I6F3GV
100 */
101 HWTEST_F(UntarFileSupTest, SUB_Untar_File_IsEmptyBlock_0100, testing::ext::TestSize.Level1)
102 {
103 GTEST_LOG_(INFO) << "UntarFileSupTest-begin SUB_Untar_File_IsEmptyBlock_0100";
104 try {
105 EXPECT_EQ(IsEmptyBlock(nullptr), true);
106 char buff[BLOCK_SIZE] = {0};
107 EXPECT_EQ(IsEmptyBlock(buff), true);
108 } catch (...) {
109 EXPECT_TRUE(false);
110 GTEST_LOG_(INFO) << "UntarFileSupTest-an exception occurred by IsEmptyBlock.";
111 }
112 GTEST_LOG_(INFO) << "UntarFileSupTest-end SUB_Untar_File_IsEmptyBlock_0100";
113 }
114
115 /**
116 * @tc.number: SUB_Untar_File_ParseOctalStr_0100
117 * @tc.name: SUB_Untar_File_ParseOctalStr_0100
118 * @tc.desc: 测试 ParseOctalStr 接口
119 * @tc.size: MEDIUM
120 * @tc.type: FUNC
121 * @tc.level Level 1
122 * @tc.require: I6F3GV
123 */
124 HWTEST_F(UntarFileSupTest, SUB_Untar_File_ParseOctalStr_0100, testing::ext::TestSize.Level1)
125 {
126 GTEST_LOG_(INFO) << "UntarFileSupTest-begin SUB_Untar_File_ParseOctalStr_0100";
127 EXPECT_EQ(ParseOctalStr("0", 0), 0);
128 EXPECT_EQ(ParseOctalStr("1234", 0), 0);
129 EXPECT_EQ(ParseOctalStr("()-891234", 10), 668);
130 GTEST_LOG_(INFO) << "UntarFileSupTest-end SUB_Untar_File_ParseOctalStr_0100";
131 }
132
133 /**
134 * @tc.number: SUB_Untar_File_GenRealPath_0100
135 * @tc.name: SUB_Untar_File_GenRealPath_0100
136 * @tc.desc: 测试 GenRealPath 接口
137 * @tc.size: MEDIUM
138 * @tc.type: FUNC
139 * @tc.level Level 1
140 * @tc.require: I6F3GV
141 */
142 HWTEST_F(UntarFileSupTest, SUB_Untar_File_GenRealPath_0100, testing::ext::TestSize.Level1)
143 {
144 GTEST_LOG_(INFO) << "UntarFileSupTest-begin SUB_Untar_File_GenRealPath_0100";
145 string rootPath = "";
146 string realName = "";
147 EXPECT_EQ(UntarFile::GetInstance().GenRealPath(rootPath, realName), "");
148
149 rootPath = "rootPath";
150 EXPECT_EQ(UntarFile::GetInstance().GenRealPath(rootPath, realName), "");
151
152 realName = "realName";
153 EXPECT_EQ(UntarFile::GetInstance().GenRealPath(rootPath, realName), "rootPath/realName");
154
155 rootPath = "/rootPath/";
156 realName = "/realName";
157 EXPECT_EQ(UntarFile::GetInstance().GenRealPath(rootPath, realName), "rootPath/realName");
158 GTEST_LOG_(INFO) << "UntarFileSupTest-end SUB_Untar_File_GenRealPath_0100";
159 }
160
161 /**
162 * @tc.number: SUB_Untar_File_ForceCreateDirectoryWithMode_0100
163 * @tc.name: SUB_Untar_File_ForceCreateDirectoryWithMode_0100
164 * @tc.desc: 测试 ForceCreateDirectoryWithMode 接口
165 * @tc.size: MEDIUM
166 * @tc.type: FUNC
167 * @tc.level Level 1
168 * @tc.require: I6F3GV
169 */
170 HWTEST_F(UntarFileSupTest, SUB_Untar_File_ForceCreateDirectoryWithMode_0100, testing::ext::TestSize.Level1)
171 {
172 GTEST_LOG_(INFO) << "UntarFileSupTest-begin SUB_Untar_File_ForceCreateDirectoryWithMode_0100";
173 string rootPath = "rootPath/realName";
174 EXPECT_CALL(*funcMock, access(_, _)).WillOnce(Return(1));
175 EXPECT_CALL(*funcMock, mkdir(_, _)).WillOnce(Return(1));
176 EXPECT_EQ(ForceCreateDirectoryWithMode(rootPath, S_IRWXU), false);
177
178 EXPECT_CALL(*funcMock, access(_, _)).WillOnce(Return(0)).WillOnce(Return(1)).WillOnce(Return(0));
179 EXPECT_CALL(*funcMock, mkdir(_, _)).WillOnce(Return(0));
180 EXPECT_EQ(ForceCreateDirectoryWithMode(rootPath, S_IRWXU), true);
181
182 EXPECT_CALL(*funcMock, access(_, _)).WillOnce(Return(0)).WillOnce(Return(1)).WillOnce(Return(1));
183 EXPECT_CALL(*funcMock, mkdir(_, _)).WillOnce(Return(0));
184 EXPECT_EQ(ForceCreateDirectoryWithMode(rootPath, S_IRWXU), false);
185 GTEST_LOG_(INFO) << "UntarFileSupTest-end SUB_Untar_File_ParseOctalStr_0100";
186 }
187
188 /**
189 * @tc.number: SUB_Untar_File_ReadLongName_0100
190 * @tc.name: SUB_Untar_File_ReadLongName_0100
191 * @tc.desc: 测试 ReadLongName 接口
192 * @tc.size: MEDIUM
193 * @tc.type: FUNC
194 * @tc.level Level 1
195 * @tc.require: I6F3GV
196 */
197 HWTEST_F(UntarFileSupTest, SUB_Untar_File_ReadLongName_0100, testing::ext::TestSize.Level1)
198 {
199 GTEST_LOG_(INFO) << "UntarFileSupTest-begin SUB_Untar_File_ReadLongName_0100";
200 FileStatInfo info;
201 info.fullPath = "test";
202 UntarFile::GetInstance().tarFileSize_ = PATH_MAX_LEN + 1;
203 auto [ret, fileInfo] = UntarFile::GetInstance().ReadLongName(info);
204 EXPECT_EQ(ret, -1);
205
206 UntarFile::GetInstance().tarFileSize_ = PATH_MAX_LEN;
207 EXPECT_CALL(*funcMock, fread(_, _, _, _)).WillOnce(Return(1));
208 tie(ret, fileInfo) = UntarFile::GetInstance().ReadLongName(info);
209 EXPECT_EQ(ret, -1);
210
211 UntarFile::GetInstance().tarFileSize_ = PATH_MAX_LEN;
212 EXPECT_CALL(*funcMock, fread(_, _, _, _)).WillOnce(Return(PATH_MAX_LEN));
213 EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(1));
214 tie(ret, fileInfo) = UntarFile::GetInstance().ReadLongName(info);
215 EXPECT_EQ(ret, -1);
216
217 UntarFile::GetInstance().tarFileSize_ = PATH_MAX_LEN;
218 EXPECT_CALL(*funcMock, fread(_, _, _, _)).WillOnce(Return(PATH_MAX_LEN));
219 EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(0));
220 tie(ret, fileInfo) = UntarFile::GetInstance().ReadLongName(info);
221 EXPECT_EQ(ret, 0);
222 GTEST_LOG_(INFO) << "UntarFileSupTest-end SUB_Untar_File_ParseOctalStr_0100";
223 }
224
225 /**
226 * @tc.number: SUB_Untar_File_CreateDir_0100
227 * @tc.name: SUB_Untar_File_CreateDir_0100
228 * @tc.desc: 测试 CreateDir 接口
229 * @tc.size: MEDIUM
230 * @tc.type: FUNC
231 * @tc.level Level 1
232 * @tc.require: I6F3GV
233 */
234 HWTEST_F(UntarFileSupTest, SUB_Untar_File_CreateDir_0100, testing::ext::TestSize.Level1)
235 {
236 GTEST_LOG_(INFO) << "UntarFileSupTest-begin SUB_Untar_File_CreateDir_0100";
237 string rootPath = "";
238 try {
239 UntarFile::GetInstance().CreateDir(rootPath, S_IRWXU);
240 rootPath = "rootPath/realName";
241 EXPECT_CALL(*funcMock, access(_, _)).WillOnce(Return(0));
242 UntarFile::GetInstance().CreateDir(rootPath, S_IRWXU);
243
244 rootPath = "rootPath/realName/";
245 EXPECT_CALL(*funcMock, access(_, _)).WillOnce(Return(0));
246 UntarFile::GetInstance().CreateDir(rootPath, S_IRWXU);
247
248 rootPath = "rootPath/realName";
249 EXPECT_CALL(*funcMock, access(_, _)).WillOnce(Return(1)).WillOnce(Return(0))
250 .WillOnce(Return(1)).WillOnce(Return(0));
251 EXPECT_CALL(*funcMock, mkdir(_, _)).WillOnce(Return(0));
252 UntarFile::GetInstance().CreateDir(rootPath, S_IRWXU);
253
254 EXPECT_CALL(*funcMock, access(_, _)).WillOnce(Return(1)).WillOnce(Return(0))
255 .WillOnce(Return(1)).WillOnce(Return(1));
256 EXPECT_CALL(*funcMock, mkdir(_, _)).WillOnce(Return(0));
257 UntarFile::GetInstance().CreateDir(rootPath, S_IRWXU);
258 } catch (...) {
259 EXPECT_TRUE(false);
260 GTEST_LOG_(INFO) << "UntarFileSupTest-an exception occurred by CreateDir.";
261 }
262 GTEST_LOG_(INFO) << "UntarFileSupTest-end SUB_Untar_File_CreateDir_0100";
263 }
264
265 /**
266 * @tc.number: SUB_Untar_File_ParseFileByTypeFlag_0100
267 * @tc.name: SUB_Untar_File_ParseFileByTypeFlag_0100
268 * @tc.desc: 测试 ParseFileByTypeFlag 接口
269 * @tc.size: MEDIUM
270 * @tc.type: FUNC
271 * @tc.level Level 1
272 * @tc.require: I6F3GV
273 */
274 HWTEST_F(UntarFileSupTest, SUB_Untar_File_ParseFileByTypeFlag_0100, testing::ext::TestSize.Level1)
275 {
276 GTEST_LOG_(INFO) << "UntarFileSupTest-begin SUB_Untar_File_CreateDir_0100";
277 UntarFile::GetInstance().rootPath_ = "rootPath";
278 try {
279 char c = '\0';
280 FileStatInfo info;
281 info.fullPath = "/test.txt";
282 EXPECT_CALL(*funcMock, realpath(_, _)).WillOnce(Return(&c));
283 EXPECT_CALL(*funcMock, fopen(_, _)).WillOnce(Return(nullptr));
284 EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(0));
285 auto [ret, flag, m] = UntarFile::GetInstance().ParseFileByTypeFlag(REGTYPE, info);
286 EXPECT_EQ(ret, 0);
287 EXPECT_FALSE(flag);
288
289 info.fullPath = "/test/../test.txt";
290 tie(ret, flag, std::ignore) = UntarFile::GetInstance().ParseFileByTypeFlag(REGTYPE, info);
291 EXPECT_EQ(ret, DEFAULT_ERR);
292 EXPECT_TRUE(flag);
293
294 info.fullPath = "/test.txt";
295 EXPECT_CALL(*funcMock, realpath(_, _)).WillOnce(Return(&c));
296 EXPECT_CALL(*funcMock, fopen(_, _)).WillOnce(Return(nullptr));
297 EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(0));
298 tie(ret, flag, std::ignore) = UntarFile::GetInstance().ParseFileByTypeFlag(AREGTYPE, info);
299 EXPECT_EQ(ret, 0);
300 EXPECT_FALSE(flag);
301
302 info.fullPath = "/test/../test.txt";
303 tie(ret, flag, std::ignore) = UntarFile::GetInstance().ParseFileByTypeFlag(AREGTYPE, info);
304 EXPECT_EQ(ret, DEFAULT_ERR);
305 EXPECT_TRUE(flag);
306
307 tie(ret, flag, std::ignore) = UntarFile::GetInstance().ParseFileByTypeFlag(SYMTYPE, info);
308 EXPECT_EQ(ret, 0);
309 EXPECT_TRUE(flag);
310
311 info.fullPath = "/test/";
312 EXPECT_CALL(*funcMock, access(_, _)).WillOnce(Return(0));
313 tie(ret, flag, std::ignore) = UntarFile::GetInstance().ParseFileByTypeFlag(DIRTYPE, info);
314 EXPECT_EQ(ret, 0);
315 EXPECT_FALSE(flag);
316
317 info.fullPath = "/test/../test/";
318 tie(ret, flag, std::ignore) = UntarFile::GetInstance().ParseFileByTypeFlag(DIRTYPE, info);
319 EXPECT_EQ(ret, DEFAULT_ERR);
320 EXPECT_TRUE(flag);
321 } catch (...) {
322 EXPECT_TRUE(false);
323 GTEST_LOG_(INFO) << "UntarFileSupTest-an exception occurred by ParseFileByTypeFlag.";
324 }
325 GTEST_LOG_(INFO) << "UntarFileSupTest-end SUB_Untar_File_CreateDir_0100";
326 }
327
328 /**
329 * @tc.number: SUB_Untar_File_ParseFileByTypeFlag_0200
330 * @tc.name: SUB_Untar_File_ParseFileByTypeFlag_0200
331 * @tc.desc: 测试 ParseFileByTypeFlag 接口
332 * @tc.size: MEDIUM
333 * @tc.type: FUNC
334 * @tc.level Level 1
335 * @tc.require: I6F3GV
336 */
337 HWTEST_F(UntarFileSupTest, SUB_Untar_File_ParseFileByTypeFlag_0200, testing::ext::TestSize.Level1)
338 {
339 GTEST_LOG_(INFO) << "UntarFileSupTest-begin SUB_Untar_File_CreateDir_0100";
340 UntarFile::GetInstance().rootPath_ = "rootPath";
341 try {
342 FileStatInfo info;
343 UntarFile::GetInstance().tarFileSize_ = PATH_MAX_LEN + 1;
344 info.fullPath = "/test/../test/";
345 auto [ret, flag, m] = UntarFile::GetInstance().ParseFileByTypeFlag(GNUTYPE_LONGNAME, info);
346 EXPECT_EQ(ret, DEFAULT_ERR);
347 EXPECT_TRUE(flag);
348
349 info.fullPath = "/test";
350 info.longName = "/test/../longName";
351 tie(ret, flag, std::ignore) = UntarFile::GetInstance().ParseFileByTypeFlag(GNUTYPE_LONGNAME, info);
352 EXPECT_EQ(ret, DEFAULT_ERR);
353 EXPECT_TRUE(flag);
354
355 info.fullPath = "/test";
356 info.longName = "longName";
357 tie(ret, flag, std::ignore) = UntarFile::GetInstance().ParseFileByTypeFlag(GNUTYPE_LONGNAME, info);
358 EXPECT_EQ(ret, DEFAULT_ERR);
359 EXPECT_TRUE(flag);
360
361 EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(0));
362 tie(ret, flag, std::ignore) = UntarFile::GetInstance().ParseFileByTypeFlag('6', info);
363 EXPECT_EQ(ret, 0);
364 EXPECT_TRUE(flag);
365
366 EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(-1));
367 tie(ret, flag, std::ignore) = UntarFile::GetInstance().ParseFileByTypeFlag('6', info);
368 EXPECT_EQ(ret, DEFAULT_ERR);
369 EXPECT_TRUE(flag);
370 } catch (...) {
371 EXPECT_TRUE(false);
372 GTEST_LOG_(INFO) << "UntarFileSupTest-an exception occurred by ParseFileByTypeFlag.";
373 }
374 GTEST_LOG_(INFO) << "UntarFileSupTest-end SUB_Untar_File_CreateDir_0200";
375 }
376
377 /**
378 * @tc.number: SUB_Untar_File_DealFileTag_0100
379 * @tc.name: SUB_Untar_File_DealFileTag_0100
380 * @tc.desc: 测试 DealFileTag 接口
381 * @tc.size: MEDIUM
382 * @tc.type: FUNC
383 * @tc.level Level 1
384 * @tc.require: I6F3GV
385 */
386 HWTEST_F(UntarFileSupTest, SUB_Untar_File_DealFileTag_0100, testing::ext::TestSize.Level1)
387 {
388 GTEST_LOG_(INFO) << "UntarFileSupTest-begin SUB_Untar_File_DealFileTag_0100";
389 try {
390 char c = '\0';
391 ErrFileInfo errFileInfo;
392 FileStatInfo info;
393 bool isFilter = false;
394 std::string tmpFullPath;
395 info.fullPath = "/test.txt";
396 UntarFile::GetInstance().includes_.clear();
397 EXPECT_CALL(*funcMock, realpath(_, _)).WillOnce(Return(&c));
398 EXPECT_CALL(*funcMock, fopen(_, _)).WillOnce(Return(nullptr));
399 EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(0));
400 EXPECT_EQ(UntarFile::GetInstance().DealFileTag(errFileInfo, info, isFilter, tmpFullPath), true);
401
402 info.fullPath = "/../test.txt";
403 UntarFile::GetInstance().rootPath_ = "/root/";
404 EXPECT_EQ(UntarFile::GetInstance().DealFileTag(errFileInfo, info, isFilter, tmpFullPath), false);
405
406 ReportFileInfo report;
407 UntarFile::GetInstance().includes_.emplace("/test/", report);
408 EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(0));
409 EXPECT_EQ(UntarFile::GetInstance().DealFileTag(errFileInfo, info, isFilter, tmpFullPath), true);
410
411 EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(-1));
412 EXPECT_EQ(UntarFile::GetInstance().DealFileTag(errFileInfo, info, isFilter, tmpFullPath), false);
413
414 tmpFullPath = "/test/";
415 info.fullPath = "/test.txt";
416 EXPECT_CALL(*funcMock, realpath(_, _)).WillOnce(Return(&c));
417 EXPECT_CALL(*funcMock, fopen(_, _)).WillOnce(Return(nullptr));
418 EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(0));
419 EXPECT_EQ(UntarFile::GetInstance().DealFileTag(errFileInfo, info, isFilter, tmpFullPath), true);
420 } catch (...) {
421 EXPECT_TRUE(false);
422 GTEST_LOG_(INFO) << "UntarFileSupTest-an exception occurred by DealFileTag.";
423 }
424 GTEST_LOG_(INFO) << "UntarFileSupTest-end SUB_Untar_File_DealFileTag_0100";
425 }
426
427 /**
428 * @tc.number: SUB_Untar_File_ParseIncrementalFileByTypeFlag_0100
429 * @tc.name: SUB_Untar_File_ParseIncrementalFileByTypeFlag_0100
430 * @tc.desc: 测试 ParseIncrementalFileByTypeFlag 接口
431 * @tc.size: MEDIUM
432 * @tc.type: FUNC
433 * @tc.level Level 1
434 * @tc.require: I6F3GV
435 */
436 HWTEST_F(UntarFileSupTest, SUB_Untar_File_ParseIncrementalFileByTypeFlag_0100, testing::ext::TestSize.Level1)
437 {
438 GTEST_LOG_(INFO) << "UntarFileSupTest-begin SUB_Untar_File_CreateDir_0100";
439 UntarFile::GetInstance().rootPath_ = "rootPath";
440 try {
441 char c = '\0';
442 FileStatInfo info;
443 info.fullPath = "/test.txt";
444 UntarFile::GetInstance().includes_.clear();
445 EXPECT_CALL(*funcMock, realpath(_, _)).WillOnce(Return(&c));
446 EXPECT_CALL(*funcMock, fopen(_, _)).WillOnce(Return(nullptr));
447 EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(0));
448 auto [ret, flag, m] = UntarFile::GetInstance().ParseIncrementalFileByTypeFlag(REGTYPE, info);
449 EXPECT_EQ(ret, 0);
450 EXPECT_FALSE(flag);
451
452 info.fullPath = "/test/../test.txt";
453 tie(ret, flag, std::ignore) = UntarFile::GetInstance().ParseIncrementalFileByTypeFlag(REGTYPE, info);
454 EXPECT_EQ(ret, DEFAULT_ERR);
455 EXPECT_TRUE(flag);
456
457 info.fullPath = "/test.txt";
458 EXPECT_CALL(*funcMock, realpath(_, _)).WillOnce(Return(&c));
459 EXPECT_CALL(*funcMock, fopen(_, _)).WillOnce(Return(nullptr));
460 EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(0));
461 tie(ret, flag, std::ignore) = UntarFile::GetInstance().ParseIncrementalFileByTypeFlag(AREGTYPE, info);
462 EXPECT_EQ(ret, 0);
463 EXPECT_FALSE(flag);
464
465 info.fullPath = "/test/../test.txt";
466 tie(ret, flag, std::ignore) = UntarFile::GetInstance().ParseIncrementalFileByTypeFlag(AREGTYPE, info);
467 EXPECT_EQ(ret, DEFAULT_ERR);
468 EXPECT_TRUE(flag);
469
470 tie(ret, flag, std::ignore) = UntarFile::GetInstance().ParseIncrementalFileByTypeFlag(SYMTYPE, info);
471 EXPECT_EQ(ret, 0);
472 EXPECT_TRUE(flag);
473
474 info.fullPath = "/test/";
475 EXPECT_CALL(*funcMock, access(_, _)).WillOnce(Return(0));
476 tie(ret, flag, std::ignore) = UntarFile::GetInstance().ParseIncrementalFileByTypeFlag(DIRTYPE, info);
477 EXPECT_EQ(ret, 0);
478 EXPECT_FALSE(flag);
479
480 info.fullPath = "/test/../test/";
481 tie(ret, flag, std::ignore) = UntarFile::GetInstance().ParseIncrementalFileByTypeFlag(DIRTYPE, info);
482 EXPECT_EQ(ret, DEFAULT_ERR);
483 EXPECT_TRUE(flag);
484 } catch (...) {
485 EXPECT_TRUE(false);
486 GTEST_LOG_(INFO) << "UntarFileSupTest-an exception occurred by ParseIncrementalFileByTypeFlag.";
487 }
488 GTEST_LOG_(INFO) << "UntarFileSupTest-end SUB_Untar_File_CreateDir_0100";
489 }
490
491 /**
492 * @tc.number: SUB_Untar_File_ParseIncrementalFileByTypeFlag_0200
493 * @tc.name: SUB_Untar_File_ParseIncrementalFileByTypeFlag_0200
494 * @tc.desc: 测试 ParseIncrementalFileByTypeFlag 接口
495 * @tc.size: MEDIUM
496 * @tc.type: FUNC
497 * @tc.level Level 1
498 * @tc.require: I6F3GV
499 */
500 HWTEST_F(UntarFileSupTest, SUB_Untar_File_ParseIncrementalFileByTypeFlag_0200, testing::ext::TestSize.Level1)
501 {
502 GTEST_LOG_(INFO) << "UntarFileSupTest-begin SUB_Untar_File_CreateDir_0100";
503 UntarFile::GetInstance().rootPath_ = "rootPath";
504 try {
505 FileStatInfo info;
506 UntarFile::GetInstance().tarFileSize_ = PATH_MAX_LEN + 1;
507 info.fullPath = "/test/../test/";
508 auto [ret, flag, m] = UntarFile::GetInstance().ParseIncrementalFileByTypeFlag(GNUTYPE_LONGNAME, info);
509 EXPECT_EQ(ret, DEFAULT_ERR);
510 EXPECT_TRUE(flag);
511
512 info.fullPath = "/test";
513 tie(ret, flag, std::ignore) = UntarFile::GetInstance().ParseIncrementalFileByTypeFlag(GNUTYPE_LONGNAME, info);
514 EXPECT_EQ(ret, DEFAULT_ERR);
515 EXPECT_TRUE(flag);
516
517 EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(0));
518 tie(ret, flag, std::ignore) = UntarFile::GetInstance().ParseIncrementalFileByTypeFlag('6', info);
519 EXPECT_EQ(ret, 0);
520 EXPECT_TRUE(flag);
521
522 EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(-1));
523 tie(ret, flag, std::ignore) = UntarFile::GetInstance().ParseIncrementalFileByTypeFlag('6', info);
524 EXPECT_EQ(ret, DEFAULT_ERR);
525 EXPECT_TRUE(flag);
526 } catch (...) {
527 EXPECT_TRUE(false);
528 GTEST_LOG_(INFO) << "UntarFileSupTest-an exception occurred by ParseIncrementalFileByTypeFlag.";
529 }
530 GTEST_LOG_(INFO) << "UntarFileSupTest-end SUB_Untar_File_CreateDir_0200";
531 }
532
533 /**
534 * @tc.number: SUB_Untar_File_IsValidTarBlock_0100
535 * @tc.name: SUB_Untar_File_IsValidTarBlock_0100
536 * @tc.desc: 测试 IsValidTarBlock 接口
537 * @tc.size: MEDIUM
538 * @tc.type: FUNC
539 * @tc.level Level 1
540 * @tc.require: I6F3GV
541 */
542 HWTEST_F(UntarFileSupTest, SUB_Untar_File_IsValidTarBlock_0100, testing::ext::TestSize.Level1)
543 {
544 GTEST_LOG_(INFO) << "UntarFileSupTest-begin SUB_Untar_File_IsValidTarBlock_0100";
545 TarHeader header { .magic = "test" };
546 try {
547 EXPECT_EQ(UntarFile::GetInstance().IsValidTarBlock(header), false);
548 EXPECT_TRUE(true);
549 } catch (...) {
550 EXPECT_TRUE(false);
551 GTEST_LOG_(INFO) << "UntarFileSupTest-an exception occurred by IsValidTarBlock.";
552 }
553 GTEST_LOG_(INFO) << "UntarFileSupTest-end SUB_Untar_File_IsValidTarBlock_0100";
554 }
555
556 /**
557 * @tc.number: SUB_Untar_File_IsValidTarBlock_0200
558 * @tc.name: SUB_Untar_File_IsValidTarBlock_0200
559 * @tc.desc: 测试 IsValidTarBlock 接口
560 * @tc.size: MEDIUM
561 * @tc.type: FUNC
562 * @tc.level Level 1
563 * @tc.require: I6F3GV
564 */
565 HWTEST_F(UntarFileSupTest, SUB_Untar_File_IsValidTarBlock_0200, testing::ext::TestSize.Level1)
566 {
567 GTEST_LOG_(INFO) << "UntarFileSupTest-begin SUB_Untar_File_IsValidTarBlock_0200";
568 TarHeader header { .magic = "ustar" };
569 try {
570 EXPECT_EQ(UntarFile::GetInstance().IsValidTarBlock(header), false);
571 EXPECT_TRUE(true);
572 } catch (...) {
573 EXPECT_TRUE(false);
574 GTEST_LOG_(INFO) << "UntarFileSupTest-an exception occurred by IsValidTarBlock.";
575 }
576 GTEST_LOG_(INFO) << "UntarFileSupTest-end SUB_Untar_File_IsValidTarBlock_0200";
577 }
578
579 /**
580 * @tc.number: SUB_Untar_File_CheckIfTarBlockValid_0100
581 * @tc.name: SUB_Untar_File_CheckIfTarBlockValid_0100
582 * @tc.desc: 测试 CheckIfTarBlockValid 接口
583 * @tc.size: MEDIUM
584 * @tc.type: FUNC
585 * @tc.level Level 1
586 * @tc.require: I6F3GV
587 */
588 HWTEST_F(UntarFileSupTest, SUB_Untar_File_CheckIfTarBlockValid_0100, testing::ext::TestSize.Level1)
589 {
590 GTEST_LOG_(INFO) << "UntarFileSupTest-begin SUB_Untar_File_CheckIfTarBlockValid_0100";
591 try {
592 char buff[BLOCK_SIZE] = {0};
593 size_t buffLen = 0;
594 TarHeader header;
595 int ret = 0;
596
597 EXPECT_EQ(UntarFile::GetInstance().CheckIfTarBlockValid(nullptr, 0, nullptr, ret), false);
598
599 EXPECT_EQ(UntarFile::GetInstance().CheckIfTarBlockValid(buff, 0, nullptr, ret), false);
600
601 buffLen = BLOCK_SIZE;
602 EXPECT_EQ(UntarFile::GetInstance().CheckIfTarBlockValid(buff, buffLen, nullptr, ret), false);
603
604 buff[0] = '0';
605 EXPECT_CALL(*funcMock, ftello(_)).WillOnce(Return(0));
606 EXPECT_EQ(UntarFile::GetInstance().CheckIfTarBlockValid(buff, buffLen, &header, ret), false);
607
608 buff[0] = '\0';
609 header.typeFlag = GNUTYPE_LONGNAME;
610 UntarFile::GetInstance().tarFileSize_ = 0;
611 EXPECT_CALL(*funcMock, ftello(_)).WillOnce(Return(READ_BUFF_SIZE + 1));
612 EXPECT_EQ(UntarFile::GetInstance().CheckIfTarBlockValid(buff, buffLen, &header, ret), false);
613
614 header.typeFlag = REGTYPE;
615 EXPECT_CALL(*funcMock, fread(_, _, _, _)).WillOnce(Return(0));
616 EXPECT_CALL(*funcMock, ftello(_)).WillOnce(Return(0));
617 EXPECT_EQ(UntarFile::GetInstance().CheckIfTarBlockValid(buff, buffLen, &header, ret), false);
618
619 EXPECT_CALL(*funcMock, fread(_, _, _, _)).WillOnce(Return(BLOCK_SIZE));
620 EXPECT_EQ(UntarFile::GetInstance().CheckIfTarBlockValid(buff, buffLen, &header, ret), false);
621
__anond1dfeba50102(void* buff) 622 EXPECT_CALL(*funcMock, fread(_, _, _, _)).WillOnce(WithArgs<0>(Invoke([](void* buff) {
623 (reinterpret_cast<char*>(buff))[0] = '0';
624 return BLOCK_SIZE;
625 })));
626 EXPECT_CALL(*funcMock, ftello(_)).WillOnce(Return(0));
627 EXPECT_EQ(UntarFile::GetInstance().CheckIfTarBlockValid(buff, buffLen, &header, ret), false);
628
629 string sum = "01647";
630 header.typeFlag = 'x';
631 memcpy_s(&header.magic, sizeof(header.magic), TMAGIC.c_str(), TMAGIC.length());
632 memcpy_s(&header.chksum, sizeof(header.chksum), sum.c_str(), sum.length());
633 buff[0] = '0';
634 EXPECT_EQ(UntarFile::GetInstance().CheckIfTarBlockValid(buff, buffLen, &header, ret), true);
635 } catch (...) {
636 EXPECT_TRUE(false);
637 GTEST_LOG_(INFO) << "UntarFileSupTest-an exception occurred by CheckIfTarBlockValid.";
638 }
639 GTEST_LOG_(INFO) << "UntarFileSupTest-end SUB_Untar_File_CheckIfTarBlockValid_0100";
640 }
641
642 /**
643 * @tc.number: SUB_Untar_File_ParseRegularFile_0100
644 * @tc.name: SUB_Untar_File_ParseRegularFile_0100
645 * @tc.desc: 测试 ParseRegularFile 接口
646 * @tc.size: MEDIUM
647 * @tc.type: FUNC
648 * @tc.level Level 1
649 * @tc.require: I6F3GV
650 */
651 HWTEST_F(UntarFileSupTest, SUB_Untar_File_ParseRegularFile_0100, testing::ext::TestSize.Level1)
652 {
653 GTEST_LOG_(INFO) << "UntarFileSupTest-begin SUB_Untar_File_ParseRegularFile_0100";
654 try {
655 char c = '\0';
656 FileStatInfo info;
657 info.fullPath = "/test.txt";
658 EXPECT_CALL(*funcMock, realpath(_, _)).WillOnce(Return(&c));
659 EXPECT_CALL(*funcMock, fopen(_, _)).WillOnce(Return(nullptr));
660 EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(0));
661 auto ret = UntarFile::GetInstance().ParseRegularFile(info);
662 EXPECT_EQ(ret[info.fullPath].size(), 1);
663
664 UntarFile::GetInstance().tarFileSize_ = READ_BUFF_SIZE + READ_BUFF_SIZE - 1;
665 EXPECT_CALL(*funcMock, realpath(_, _)).WillOnce(Return(&c));
666 EXPECT_CALL(*funcMock, fopen(_, _)).WillOnce(Return(reinterpret_cast<FILE*>(&c)));
667 EXPECT_CALL(*funcMock, fread(_, _, _, _))
668 .WillOnce(Return(READ_BUFF_SIZE))
669 .WillOnce(Return(READ_BUFF_SIZE >> 1))
670 .WillOnce(Return((READ_BUFF_SIZE >> 1) - 1));
671 EXPECT_CALL(*funcMock, fwrite(_, _, _, _))
672 .WillOnce(Return(READ_BUFF_SIZE))
673 .WillOnce(Return(READ_BUFF_SIZE >> 1))
674 .WillOnce(Return((READ_BUFF_SIZE >> 1) - 1));
675 EXPECT_CALL(*funcMock, fclose(_)).WillOnce(Return(0));
676 EXPECT_CALL(*funcMock, chmod(_, _)).WillOnce(Return(0));
677 EXPECT_CALL(*funcMock, stat(_, _)).WillOnce(Return(0));
678 EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(0));
679 ret = UntarFile::GetInstance().ParseRegularFile(info);
680 EXPECT_EQ(ret[info.fullPath].size(), 0);
681
682 UntarFile::GetInstance().tarFileSize_ = 0;
683 EXPECT_CALL(*funcMock, realpath(_, _)).WillOnce(Return(&c));
684 EXPECT_CALL(*funcMock, fopen(_, _)).WillOnce(Return(reinterpret_cast<FILE*>(&c)));
685 EXPECT_CALL(*funcMock, fclose(_)).WillOnce(Return(0));
686 EXPECT_CALL(*funcMock, chmod(_, _)).WillOnce(Return(1));
687 EXPECT_CALL(*funcMock, stat(_, _)).WillOnce(Return(0));
688 EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(0));
689 ret = UntarFile::GetInstance().ParseRegularFile(info);
690 EXPECT_EQ(ret[info.fullPath].size(), 1);
691 } catch (...) {
692 EXPECT_TRUE(false);
693 GTEST_LOG_(INFO) << "UntarFileSupTest-an exception occurred by ParseRegularFile.";
694 }
695 GTEST_LOG_(INFO) << "UntarFileSupTest-end SUB_Untar_File_ParseRegularFile_0100";
696 }
697
698 /**
699 * @tc.number: SUB_Untar_File_ParseRegularFile_0200
700 * @tc.name: SUB_Untar_File_ParseRegularFile_0200
701 * @tc.desc: 测试 ParseRegularFile 接口
702 * @tc.size: MEDIUM
703 * @tc.type: FUNC
704 * @tc.level Level 1
705 * @tc.require: I6F3GV
706 */
707 HWTEST_F(UntarFileSupTest, SUB_Untar_File_ParseRegularFile_0200, testing::ext::TestSize.Level1)
708 {
709 GTEST_LOG_(INFO) << "UntarFileSupTest-begin SUB_Untar_File_ParseRegularFile_0200";
710 try {
711 char c = '\0';
712 FileStatInfo info;
713 info.fullPath = "/test.txt";
714 UntarFile::GetInstance().tarFileSize_ = 0;
715 EXPECT_CALL(*funcMock, realpath(_, _)).WillOnce(Return(&c));
716 EXPECT_CALL(*funcMock, fopen(_, _)).WillOnce(Return(reinterpret_cast<FILE*>(&c)));
717 EXPECT_CALL(*funcMock, fclose(_)).WillOnce(Return(0));
718 EXPECT_CALL(*funcMock, chmod(_, _)).WillOnce(Return(0));
719 EXPECT_CALL(*funcMock, stat(_, _)).WillOnce(Return(1));
720 EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(0));
721 auto ret = UntarFile::GetInstance().ParseRegularFile(info);
722 EXPECT_EQ(ret[info.fullPath].size(), 1);
723
724 info.mtime = 1;
725 EXPECT_CALL(*funcMock, realpath(_, _)).WillOnce(Return(&c));
726 EXPECT_CALL(*funcMock, fopen(_, _)).WillOnce(Return(reinterpret_cast<FILE*>(&c)));
727 EXPECT_CALL(*funcMock, fclose(_)).WillOnce(Return(0));
728 EXPECT_CALL(*funcMock, chmod(_, _)).WillOnce(Return(0));
729 EXPECT_CALL(*funcMock, stat(_, _)).WillOnce(Return(0));
730 EXPECT_CALL(*funcMock, utime(_, _)).WillOnce(Return(0));
731 EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(0));
732 ret = UntarFile::GetInstance().ParseRegularFile(info);
733 EXPECT_EQ(ret[info.fullPath].size(), 0);
734
735 EXPECT_CALL(*funcMock, realpath(_, _)).WillOnce(Return(&c));
736 EXPECT_CALL(*funcMock, fopen(_, _)).WillOnce(Return(reinterpret_cast<FILE*>(&c)));
737 EXPECT_CALL(*funcMock, fclose(_)).WillOnce(Return(0));
738 EXPECT_CALL(*funcMock, chmod(_, _)).WillOnce(Return(0));
739 EXPECT_CALL(*funcMock, stat(_, _)).WillOnce(Return(0));
740 EXPECT_CALL(*funcMock, utime(_, _)).WillOnce(Return(1));
741 EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(0));
742 ret = UntarFile::GetInstance().ParseRegularFile(info);
743 EXPECT_EQ(ret[info.fullPath].size(), 1);
744 } catch (...) {
745 EXPECT_TRUE(false);
746 GTEST_LOG_(INFO) << "UntarFileSupTest-an exception occurred by ParseRegularFile.";
747 }
748 GTEST_LOG_(INFO) << "UntarFileSupTest-end SUB_Untar_File_ParseRegularFile_0200";
749 }
750
751 /**
752 * @tc.number: SUB_Untar_File_UnPacket_0100
753 * @tc.name: SUB_Untar_File_UnPacket_0100
754 * @tc.desc: 测试 UnPacket 接口
755 * @tc.size: MEDIUM
756 * @tc.type: FUNC
757 * @tc.level Level 1
758 * @tc.require: I6F3GV
759 */
760 HWTEST_F(UntarFileSupTest, SUB_Untar_File_UnPacket_0100, testing::ext::TestSize.Level1)
761 {
762 GTEST_LOG_(INFO) << "UntarFileSupTest-begin SUB_Untar_File_UnPacket_0100";
763 try {
764 string tarFile;
765 string rootPath;
766 errno = EPERM;
767 EXPECT_CALL(*funcMock, fopen(_, _)).WillOnce(Return(nullptr));
768 auto [ret, info, err] = UntarFile::GetInstance().UnPacket(tarFile, rootPath);
769 EXPECT_EQ(ret, EPERM);
770
771 char c = '\0';
772 EXPECT_CALL(*funcMock, fopen(_, _)).WillOnce(Return(reinterpret_cast<FILE*>(&c)));
773 EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(0)).WillOnce(Return(1));
774 EXPECT_CALL(*funcMock, ftello(_)).WillOnce(Return(0));
775 EXPECT_CALL(*funcMock, fclose(_)).WillOnce(Return(0));
776 tie(ret, info, err) = UntarFile::GetInstance().UnPacket(tarFile, rootPath);
777 EXPECT_EQ(ret, 0);
778
779 EXPECT_CALL(*funcMock, fopen(_, _)).WillOnce(Return(reinterpret_cast<FILE*>(&c)));
780 EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(0)).WillOnce(Return(0));
781 EXPECT_CALL(*funcMock, ftello(_)).WillOnce(Return(0));
782 EXPECT_CALL(*funcMock, fread(_, _, _, _)).WillOnce(Return(0));
783 EXPECT_CALL(*funcMock, fclose(_)).WillOnce(Return(0));
784 tie(ret, info, err) = UntarFile::GetInstance().UnPacket(tarFile, rootPath);
785 EXPECT_EQ(ret, 0);
786 } catch (...) {
787 EXPECT_TRUE(false);
788 GTEST_LOG_(INFO) << "UntarFileSupTest-an exception occurred by UnPacket.";
789 }
790 GTEST_LOG_(INFO) << "UntarFileSupTest-end SUB_Untar_File_UnPacket_0100";
791 }
792
793 /**
794 * @tc.number: SUB_Untar_File_IncrementalUnPacket_0100
795 * @tc.name: SUB_Untar_File_IncrementalUnPacket_0100
796 * @tc.desc: 测试 IncrementalUnPacket 接口
797 * @tc.size: MEDIUM
798 * @tc.type: FUNC
799 * @tc.level Level 1
800 * @tc.require: I6F3GV
801 */
802 HWTEST_F(UntarFileSupTest, SUB_Untar_File_IncrementalUnPacket_0100, testing::ext::TestSize.Level1)
803 {
804 GTEST_LOG_(INFO) << "UntarFileSupTest-begin SUB_Untar_File_IncrementalUnPacket_0100";
805 try {
806 string tarFile;
807 string rootPath;
808 errno = EPERM;
809 unordered_map<string, struct ReportFileInfo> includes;
810 EXPECT_CALL(*funcMock, fopen(_, _)).WillOnce(Return(nullptr));
811 auto [ret, info, err] = UntarFile::GetInstance().IncrementalUnPacket(tarFile, rootPath, includes);
812 EXPECT_EQ(ret, EPERM);
813
814 char c = '\0';
815 EXPECT_CALL(*funcMock, fopen(_, _)).WillOnce(Return(reinterpret_cast<FILE*>(&c)));
816 EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(0)).WillOnce(Return(1));
817 EXPECT_CALL(*funcMock, ftello(_)).WillOnce(Return(0));
818 EXPECT_CALL(*funcMock, fclose(_)).WillOnce(Return(0));
819 tie(ret, info, err) = UntarFile::GetInstance().IncrementalUnPacket(tarFile, rootPath, includes);
820 EXPECT_EQ(ret, 0);
821
822 EXPECT_CALL(*funcMock, fopen(_, _)).WillOnce(Return(reinterpret_cast<FILE*>(&c)));
823 EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(0)).WillOnce(Return(0));
824 EXPECT_CALL(*funcMock, ftello(_)).WillOnce(Return(0));
825 EXPECT_CALL(*funcMock, fread(_, _, _, _)).WillOnce(Return(0));
826 EXPECT_CALL(*funcMock, fclose(_)).WillOnce(Return(0));
827 tie(ret, info, err) = UntarFile::GetInstance().IncrementalUnPacket(tarFile, rootPath, includes);
828 EXPECT_EQ(ret, 0);
829 } catch (...) {
830 EXPECT_TRUE(false);
831 GTEST_LOG_(INFO) << "UntarFileSupTest-an exception occurred by IncrementalUnPacket.";
832 }
833 GTEST_LOG_(INFO) << "UntarFileSupTest-end SUB_Untar_File_IncrementalUnPacket_0100";
834 }
835
CalcChecksum(TarHeader & header)836 [[maybe_unused]] static off_t CalcChecksum(TarHeader &header)
837 {
838 vector<uint8_t> buffer {};
839 buffer.resize(sizeof(header));
840 buffer.assign(reinterpret_cast<uint8_t *>(&header), reinterpret_cast<uint8_t *>(&header) + sizeof(header));
841 off_t sum = 0;
842 for (uint32_t index = 0; index < BLOCK_SIZE; ++index) {
843 if (index < CHKSUM_BASE || index > CHKSUM_BASE + CHKSUM_LEN - 1) {
844 // Standard tar checksum adds unsigned bytes.
845 sum += (buffer[index] & 0xFF);
846 } else {
847 sum += BLANK_SPACE;
848 }
849 }
850 return sum;
851 }
852
853 /**
854 * @tc.number: SUB_Untar_File_ParseTarFile_0100
855 * @tc.name: SUB_Untar_File_ParseTarFile_0100
856 * @tc.desc: 测试 ParseTarFile 接口
857 * @tc.size: MEDIUM
858 * @tc.type: FUNC
859 * @tc.level Level 1
860 * @tc.require: I6F3GV
861 */
862 HWTEST_F(UntarFileSupTest, SUB_Untar_File_ParseTarFile_0100, testing::ext::TestSize.Level1)
863 {
864 GTEST_LOG_(INFO) << "UntarFileSupTest-begin SUB_Untar_File_ParseTarFile_0100";
865 try {
866 string tarFile;
867 string rootPath;
868 errno = EPERM;
869 EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(errno));
870 auto [ret, info, err] = UntarFile::GetInstance().ParseTarFile(rootPath);
871 EXPECT_EQ(ret, EPERM);
872
873 EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(0)).WillOnce(Return(0));
874 EXPECT_CALL(*funcMock, ftello(_)).WillOnce(Return(0));
875 EXPECT_CALL(*funcMock, fread(_, _, _, _)).WillOnce(Return(0));
876 tie(ret, info, err) = UntarFile::GetInstance().ParseTarFile(rootPath);
877 EXPECT_EQ(ret, 0);
878
879 EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(0)).WillOnce(Return(0));
880 EXPECT_CALL(*funcMock, ftello(_)).WillOnce(Return(0));
881 EXPECT_CALL(*funcMock, fread(_, _, _, _)).WillOnce(Return(BLOCK_SIZE)).WillOnce(Return(BLOCK_SIZE));
882 tie(ret, info, err) = UntarFile::GetInstance().ParseTarFile(rootPath);
883 EXPECT_EQ(ret, 0);
884
885 string sum = "01647";
886 TarHeader header;
887 header.typeFlag = 'y';
888 memcpy_s(&header.magic, sizeof(header.magic), TMAGIC.c_str(), TMAGIC.length());
889 memcpy_s(&header.chksum, sizeof(header.chksum), sum.c_str(), sum.length());
890 EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(0)).WillOnce(Return(0)).WillOnce(Return(EPERM));
891 EXPECT_CALL(*funcMock, ftello(_)).WillOnce(Return(0)).WillOnce(Return(0));
__anond1dfeba50202(void* buff) 892 EXPECT_CALL(*funcMock, fread(_, _, _, _)).WillOnce(WithArgs<0>(Invoke([&header](void* buff) {
893 memcpy_s(buff, BLOCK_SIZE, &header, sizeof(header));
894 return BLOCK_SIZE;
895 }))).WillOnce(Return(0));
896 tie(ret, info, err) = UntarFile::GetInstance().ParseTarFile(rootPath);
897 EXPECT_EQ(ret, 0);
898
899 EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(0)).WillOnce(Return(0)).WillOnce(Return(0));
900 EXPECT_CALL(*funcMock, ftello(_)).WillOnce(Return(0)).WillOnce(Return(0));
__anond1dfeba50302(void* buff) 901 EXPECT_CALL(*funcMock, fread(_, _, _, _)).WillOnce(WithArgs<0>(Invoke([&header](void* buff) {
902 memcpy_s(buff, BLOCK_SIZE, &header, sizeof(header));
903 return BLOCK_SIZE;
904 }))).WillOnce(Return(0)).WillOnce(Return(0));
905 tie(ret, info, err) = UntarFile::GetInstance().ParseTarFile(rootPath);
906 EXPECT_EQ(ret, 0);
907 } catch (...) {
908 EXPECT_TRUE(false);
909 GTEST_LOG_(INFO) << "UntarFileSupTest-an exception occurred by ParseTarFile.";
910 }
911 GTEST_LOG_(INFO) << "UntarFileSupTest-end SUB_Untar_File_ParseTarFile_0100";
912 }
913
914 /**
915 * @tc.number: SUB_Untar_File_ParseTarFile_0200
916 * @tc.name: SUB_Untar_File_ParseTarFile_0200
917 * @tc.desc: 测试 ParseTarFile 接口
918 * @tc.size: MEDIUM
919 * @tc.type: FUNC
920 * @tc.level Level 1
921 * @tc.require: I6F3GV
922 */
923 HWTEST_F(UntarFileSupTest, SUB_Untar_File_ParseTarFile_0200, testing::ext::TestSize.Level1)
924 {
925 GTEST_LOG_(INFO) << "UntarFileSupTest-begin SUB_Untar_File_ParseTarFile_0200";
926 try {
927 string rootPath;
928 string sum = "01647";
929 TarHeader header;
930 header.typeFlag = 'x';
931 memcpy_s(&header.magic, sizeof(header.magic), TMAGIC.c_str(), TMAGIC.length());
932 memcpy_s(&header.chksum, sizeof(header.chksum), sum.c_str(), sum.length());
933 EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(0)).WillOnce(Return(0));
934 EXPECT_CALL(*funcMock, ftello(_)).WillOnce(Return(0)).WillOnce(Return(0));
__anond1dfeba50402(void* buff) 935 EXPECT_CALL(*funcMock, fread(_, _, _, _)).WillOnce(WithArgs<0>(Invoke([&header](void* buff) {
936 memcpy_s(buff, BLOCK_SIZE, &header, sizeof(header));
937 return BLOCK_SIZE;
938 }))).WillOnce(Return(0)).WillOnce(Return(0));
939 auto [ret, info, err] = UntarFile::GetInstance().ParseTarFile(rootPath);
940 EXPECT_EQ(ret, DEFAULT_ERR);
941 } catch (...) {
942 EXPECT_TRUE(false);
943 GTEST_LOG_(INFO) << "UntarFileSupTest-an exception occurred by ParseTarFile.";
944 }
945 GTEST_LOG_(INFO) << "UntarFileSupTest-end SUB_Untar_File_ParseTarFile_0200";
946 }
947
948 /**
949 * @tc.number: SUB_Untar_File_ParseIncrementalTarFile_0100
950 * @tc.name: SUB_Untar_File_ParseIncrementalTarFile_0100
951 * @tc.desc: 测试 ParseIncrementalTarFile 接口
952 * @tc.size: MEDIUM
953 * @tc.type: FUNC
954 * @tc.level Level 1
955 * @tc.require: I6F3GV
956 */
957 HWTEST_F(UntarFileSupTest, SUB_Untar_File_ParseIncrementalTarFile_0100, testing::ext::TestSize.Level1)
958 {
959 GTEST_LOG_(INFO) << "UntarFileSupTest-begin SUB_Untar_File_ParseIncrementalTarFile_0100";
960 try {
961 string tarFile;
962 string rootPath;
963 errno = EPERM;
964 EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(errno));
965 auto [ret, info, err] = UntarFile::GetInstance().ParseIncrementalTarFile(rootPath);
966 EXPECT_EQ(ret, EPERM);
967
968 EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(0)).WillOnce(Return(0));
969 EXPECT_CALL(*funcMock, ftello(_)).WillOnce(Return(0));
970 EXPECT_CALL(*funcMock, fread(_, _, _, _)).WillOnce(Return(0));
971 tie(ret, info, err) = UntarFile::GetInstance().ParseIncrementalTarFile(rootPath);
972 EXPECT_EQ(ret, 0);
973
974 EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(0)).WillOnce(Return(0));
975 EXPECT_CALL(*funcMock, ftello(_)).WillOnce(Return(0));
976 EXPECT_CALL(*funcMock, fread(_, _, _, _)).WillOnce(Return(BLOCK_SIZE)).WillOnce(Return(BLOCK_SIZE));
977 tie(ret, info, err) = UntarFile::GetInstance().ParseIncrementalTarFile(rootPath);
978 EXPECT_EQ(ret, 0);
979
980 string sum = "01647";
981 TarHeader header;
982 header.typeFlag = 'y';
983 memcpy_s(&header.magic, sizeof(header.magic), TMAGIC.c_str(), TMAGIC.length());
984 memcpy_s(&header.chksum, sizeof(header.chksum), sum.c_str(), sum.length());
985 EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(0)).WillOnce(Return(0)).WillOnce(Return(EPERM));
986 EXPECT_CALL(*funcMock, ftello(_)).WillOnce(Return(0)).WillOnce(Return(0));
__anond1dfeba50502(void* buff) 987 EXPECT_CALL(*funcMock, fread(_, _, _, _)).WillOnce(WithArgs<0>(Invoke([&header](void* buff) {
988 memcpy_s(buff, BLOCK_SIZE, &header, sizeof(header));
989 return BLOCK_SIZE;
990 }))).WillOnce(Return(0));
991 tie(ret, info, err) = UntarFile::GetInstance().ParseIncrementalTarFile(rootPath);
992 EXPECT_EQ(ret, 0);
993
994 EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(0)).WillOnce(Return(0)).WillOnce(Return(0));
995 EXPECT_CALL(*funcMock, ftello(_)).WillOnce(Return(0)).WillOnce(Return(0));
__anond1dfeba50602(void* buff) 996 EXPECT_CALL(*funcMock, fread(_, _, _, _)).WillOnce(WithArgs<0>(Invoke([&header](void* buff) {
997 memcpy_s(buff, BLOCK_SIZE, &header, sizeof(header));
998 return BLOCK_SIZE;
999 }))).WillOnce(Return(0)).WillOnce(Return(0));
1000 tie(ret, info, err) = UntarFile::GetInstance().ParseIncrementalTarFile(rootPath);
1001 EXPECT_EQ(ret, 0);
1002 } catch (...) {
1003 EXPECT_TRUE(false);
1004 GTEST_LOG_(INFO) << "UntarFileSupTest-an exception occurred by ParseIncrementalTarFile.";
1005 }
1006 GTEST_LOG_(INFO) << "UntarFileSupTest-end SUB_Untar_File_ParseIncrementalTarFile_0100";
1007 }
1008
1009 /**
1010 * @tc.number: SUB_Untar_File_ParseIncrementalTarFile_0200
1011 * @tc.name: SUB_Untar_File_ParseIncrementalTarFile_0200
1012 * @tc.desc: 测试 ParseIncrementalTarFile 接口
1013 * @tc.size: MEDIUM
1014 * @tc.type: FUNC
1015 * @tc.level Level 1
1016 * @tc.require: I6F3GV
1017 */
1018 HWTEST_F(UntarFileSupTest, SUB_Untar_File_ParseIncrementalTarFile_0200, testing::ext::TestSize.Level1)
1019 {
1020 GTEST_LOG_(INFO) << "UntarFileSupTest-begin SUB_Untar_File_ParseIncrementalTarFile_0200";
1021 try {
1022 string rootPath;
1023 string sum = "01647";
1024 TarHeader header;
1025 header.typeFlag = 'x';
1026 memcpy_s(&header.magic, sizeof(header.magic), TMAGIC.c_str(), TMAGIC.length());
1027 memcpy_s(&header.chksum, sizeof(header.chksum), sum.c_str(), sum.length());
1028 EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(0)).WillOnce(Return(0));
1029 EXPECT_CALL(*funcMock, ftello(_)).WillOnce(Return(0)).WillOnce(Return(0));
__anond1dfeba50702(void* buff) 1030 EXPECT_CALL(*funcMock, fread(_, _, _, _)).WillOnce(WithArgs<0>(Invoke([&header](void* buff) {
1031 memcpy_s(buff, BLOCK_SIZE, &header, sizeof(header));
1032 return BLOCK_SIZE;
1033 }))).WillOnce(Return(0)).WillOnce(Return(0));
1034 auto [ret, info, err] = UntarFile::GetInstance().ParseIncrementalTarFile(rootPath);
1035 EXPECT_EQ(ret, DEFAULT_ERR);
1036
1037 } catch (...) {
1038 EXPECT_TRUE(false);
1039 GTEST_LOG_(INFO) << "UntarFileSupTest-an exception occurred by ParseIncrementalTarFile.";
1040 }
1041 GTEST_LOG_(INFO) << "UntarFileSupTest-end SUB_Untar_File_ParseIncrementalTarFile_0200";
1042 }
1043
1044 /**
1045 * @tc.number: SUB_Untar_File_HandleTarBuffer_0100
1046 * @tc.name: SUB_Untar_File_HandleTarBuffer_0100
1047 * @tc.desc: 测试 HandleTarBuffer 接口
1048 * @tc.size: MEDIUM
1049 * @tc.type: FUNC
1050 * @tc.level Level 1
1051 * @tc.require: I6F3GV
1052 */
1053 HWTEST_F(UntarFileSupTest, SUB_Untar_File_HandleTarBuffer_0100, testing::ext::TestSize.Level1)
1054 {
1055 GTEST_LOG_(INFO) << "UntarFileSupTest-begin SUB_Untar_File_HandleTarBuffer_0100";
1056 try {
1057 char buff[BLOCK_SIZE] = {0};
1058 string name;
1059 FileStatInfo info;
1060 EXPECT_CALL(*funcMock, ftello(_)).WillOnce(Return(0));
1061 auto ret = UntarFile::GetInstance().HandleTarBuffer(buff, name, info);
1062 EXPECT_EQ(ret, 0);
1063
1064 info.longName = "longName";
1065 EXPECT_CALL(*funcMock, ftello(_)).WillOnce(Return(0));
1066 ret = UntarFile::GetInstance().HandleTarBuffer(buff, name, info);
1067 EXPECT_EQ(ret, 0);
1068
1069 name = "name";
1070 EXPECT_CALL(*funcMock, ftello(_)).WillOnce(Return(0));
1071 ret = UntarFile::GetInstance().HandleTarBuffer(buff, name, info);
1072 EXPECT_EQ(ret, 0);
1073
1074 name = "/name";
1075 EXPECT_CALL(*funcMock, ftello(_)).WillOnce(Return(0));
1076 ret = UntarFile::GetInstance().HandleTarBuffer(buff, name, info);
1077 EXPECT_EQ(ret, 0);
1078 } catch (...) {
1079 EXPECT_TRUE(false);
1080 GTEST_LOG_(INFO) << "UntarFileSupTest-an exception occurred by HandleTarBuffer.";
1081 }
1082 GTEST_LOG_(INFO) << "UntarFileSupTest-end SUB_Untar_File_HandleTarBuffer_0100";
1083 }
1084
1085 /**
1086 * @tc.number: SUB_Untar_File_CheckAndFillTarSize_0100
1087 * @tc.name: SUB_Untar_File_CheckAndFillTarSize_0100
1088 * @tc.desc: 测试 CheckAndFillTarSize 接口
1089 * @tc.size: MEDIUM
1090 * @tc.type: FUNC
1091 * @tc.level Level 1
1092 * @tc.require: I6F3GV
1093 */
1094 HWTEST_F(UntarFileSupTest, SUB_Untar_File_CheckAndFillTarSize_0100, testing::ext::TestSize.Level1)
1095 {
1096 GTEST_LOG_(INFO) << "UntarFileSupTest-begin SUB_Untar_File_CheckAndFillTarSize_0100";
1097 try {
1098 EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(EPERM));
1099 auto ret = UntarFile::GetInstance().CheckAndFillTarSize();
1100 EXPECT_EQ(ret, EPERM);
1101
1102 EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(0)).WillOnce(Return(EPERM));
1103 EXPECT_CALL(*funcMock, ftello(_)).WillOnce(Return(0));
1104 ret = UntarFile::GetInstance().CheckAndFillTarSize();
1105 EXPECT_EQ(ret, EPERM);
1106
1107 EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(0)).WillOnce(Return(0));
1108 EXPECT_CALL(*funcMock, ftello(_)).WillOnce(Return(0));
1109 ret = UntarFile::GetInstance().CheckAndFillTarSize();
1110 EXPECT_EQ(ret, 0);
1111 } catch (...) {
1112 EXPECT_TRUE(false);
1113 GTEST_LOG_(INFO) << "UntarFileSupTest-an exception occurred by CheckAndFillTarSize.";
1114 }
1115 GTEST_LOG_(INFO) << "UntarFileSupTest-end SUB_Untar_File_CheckAndFillTarSize_0100";
1116 }
1117
1118 /**
1119 * @tc.number: SUB_Untar_File_DealParseTarFileResult_0100
1120 * @tc.name: SUB_Untar_File_DealParseTarFileResult_0100
1121 * @tc.desc: 测试 DealParseTarFileResult 接口
1122 * @tc.size: MEDIUM
1123 * @tc.type: FUNC
1124 * @tc.level Level 1
1125 * @tc.require: I6F3GV
1126 */
1127 HWTEST_F(UntarFileSupTest, SUB_Untar_File_DealParseTarFileResult_0100, testing::ext::TestSize.Level1)
1128 {
1129 GTEST_LOG_(INFO) << "UntarFileSupTest-begin SUB_Untar_File_DealParseTarFileResult_0100";
1130 try {
1131 string fileName;
1132 EndFileInfo fileInfos;
1133 ErrFileInfo errs;
1134 ErrFileInfo errInfos;
1135 tuple<int, bool, ErrFileInfo> result {EPERM, false, errs};
1136 auto ret = UntarFile::GetInstance().DealParseTarFileResult(result, 0, fileName, fileInfos, errInfos);
1137 EXPECT_EQ(ret, EPERM);
1138
1139 std::get<0>(result) = 0;
1140 ret = UntarFile::GetInstance().DealParseTarFileResult(result, 1, fileName, fileInfos, errInfos);
1141 EXPECT_EQ(fileInfos[fileName], 1);
1142 EXPECT_EQ(ret, 0);
1143
1144 std::get<1>(result) = true;
1145 ret = UntarFile::GetInstance().DealParseTarFileResult(result, 0, fileName, fileInfos, errInfos);
1146 EXPECT_EQ(errInfos.size(), 0);
1147 EXPECT_EQ(ret, 0);
1148
1149 std::get<2>(result)["errno"] = {-1};
1150 errInfos.emplace("err", 0);
1151 ret = UntarFile::GetInstance().DealParseTarFileResult(result, 0, fileName, fileInfos, errInfos);
1152 EXPECT_EQ(errInfos.size(), 2);
1153 EXPECT_EQ(ret, 0);
1154 } catch (...) {
1155 EXPECT_TRUE(false);
1156 GTEST_LOG_(INFO) << "UntarFileSupTest-an exception occurred by DealParseTarFileResult.";
1157 }
1158 GTEST_LOG_(INFO) << "UntarFileSupTest-end SUB_Untar_File_DealParseTarFileResult_0100";
1159 }
1160
1161 /**
1162 * @tc.number: SUB_Untar_File_DealIncreParseTarFileResult_0100
1163 * @tc.name: SUB_Untar_File_DealIncreParseTarFileResult_0100
1164 * @tc.desc: 测试 DealIncreParseTarFileResult 接口
1165 * @tc.size: MEDIUM
1166 * @tc.type: FUNC
1167 * @tc.level Level 1
1168 * @tc.require: I6F3GV
1169 */
1170 HWTEST_F(UntarFileSupTest, SUB_Untar_File_DealIncreParseTarFileResult_0100, testing::ext::TestSize.Level1)
1171 {
1172 GTEST_LOG_(INFO) << "UntarFileSupTest-begin SUB_Untar_File_DealIncreParseTarFileResult_0100";
1173 try {
1174 string fileName;
1175 EndFileInfo fileInfos;
1176 ErrFileInfo errs;
1177 ErrFileInfo errInfos;
1178 tuple<int, bool, ErrFileInfo> result {EPERM, false, errs};
1179 auto ret = UntarFile::GetInstance().DealIncreParseTarFileResult(result, 0, fileName, fileInfos, errInfos);
1180 EXPECT_EQ(ret, EPERM);
1181
1182 std::get<0>(result) = 0;
1183 ret = UntarFile::GetInstance().DealIncreParseTarFileResult(result, 1, fileName, fileInfos, errInfos);
1184 EXPECT_EQ(fileInfos[fileName], 1);
1185 EXPECT_EQ(ret, 0);
1186
1187 std::get<1>(result) = true;
1188 ret = UntarFile::GetInstance().DealIncreParseTarFileResult(result, 0, fileName, fileInfos, errInfos);
1189 EXPECT_EQ(errInfos.size(), 0);
1190 EXPECT_EQ(ret, 0);
1191
1192 std::get<2>(result)["errno"] = {-1};
1193 errInfos.emplace("err", 0);
1194 ret = UntarFile::GetInstance().DealIncreParseTarFileResult(result, 0, fileName, fileInfos, errInfos);
1195 EXPECT_EQ(errInfos.size(), 2);
1196 EXPECT_EQ(ret, 0);
1197 } catch (...) {
1198 EXPECT_TRUE(false);
1199 GTEST_LOG_(INFO) << "UntarFileSupTest-an exception occurred by DealIncreParseTarFileResult.";
1200 }
1201 GTEST_LOG_(INFO) << "UntarFileSupTest-end SUB_Untar_File_DealIncreParseTarFileResult_0100";
1202 }
1203
1204 /**
1205 * @tc.number: SUB_Untar_File_CreateFile_0100
1206 * @tc.name: SUB_Untar_File_CreateFile_0100
1207 * @tc.desc: 测试 CreateFile 接口
1208 * @tc.size: MEDIUM
1209 * @tc.type: FUNC
1210 * @tc.level Level 1
1211 * @tc.require: I6F3GV
1212 */
1213 HWTEST_F(UntarFileSupTest, SUB_Untar_File_CreateFile_0100, testing::ext::TestSize.Level1)
1214 {
1215 GTEST_LOG_(INFO) << "UntarFileSupTest-begin SUB_Untar_File_CreateFile_0100";
1216 try {
1217 char c = '\0';
1218 string filePath;
1219 EXPECT_CALL(*funcMock, realpath(_, _)).WillOnce(Return(&c));
1220 EXPECT_CALL(*funcMock, fopen(_, _)).WillOnce(Return(nullptr));
1221 auto ret = UntarFile::GetInstance().CreateFile(filePath);
1222 EXPECT_TRUE(ret == nullptr);
1223
1224 EXPECT_CALL(*funcMock, realpath(_, _)).WillOnce(Return(&c));
1225 EXPECT_CALL(*funcMock, fopen(_, _)).WillOnce(Return(reinterpret_cast<FILE*>(&c)));
1226 ret = UntarFile::GetInstance().CreateFile(filePath);
1227 EXPECT_TRUE(ret != nullptr);
1228
1229 EXPECT_CALL(*funcMock, realpath(_, _)).WillOnce(Return(nullptr));
1230 ret = UntarFile::GetInstance().CreateFile(filePath);
1231 EXPECT_TRUE(ret == nullptr);
1232
1233 filePath = "./test.txt";
1234 EXPECT_CALL(*funcMock, realpath(_, _)).WillOnce(Return(nullptr)).WillOnce(Return(nullptr));
1235 ret = UntarFile::GetInstance().CreateFile(filePath);
1236 EXPECT_TRUE(ret == nullptr);
1237
1238 EXPECT_CALL(*funcMock, realpath(_, _)).WillOnce(Return(nullptr)).WillOnce(Return(&c));
1239 EXPECT_CALL(*funcMock, fopen(_, _)).WillOnce(Return(nullptr));
1240 ret = UntarFile::GetInstance().CreateFile(filePath);
1241 EXPECT_TRUE(ret == nullptr);
1242
1243 EXPECT_CALL(*funcMock, realpath(_, _)).WillOnce(Return(nullptr)).WillOnce(Return(&c));
1244 EXPECT_CALL(*funcMock, fopen(_, _)).WillOnce(Return(reinterpret_cast<FILE*>(&c)));
1245 ret = UntarFile::GetInstance().CreateFile(filePath);
1246 EXPECT_TRUE(ret != nullptr);
1247 } catch (...) {
1248 EXPECT_TRUE(false);
1249 GTEST_LOG_(INFO) << "UntarFileSupTest-an exception occurred by CreateFile.";
1250 }
1251 GTEST_LOG_(INFO) << "UntarFileSupTest-end SUB_Untar_File_CreateFile_0100";
1252 }
1253 } // namespace OHOS::FileManagement::Backup