diff --git a/test/fuzztest/svcrestoredepsmanager_fuzzer/svcrestoredepsmanager_fuzzer.cpp b/test/fuzztest/svcrestoredepsmanager_fuzzer/svcrestoredepsmanager_fuzzer.cpp
index f51be587a3a1841cf3ec2e3f9252f1c944d9ccc4..85d528005805c10daf24f7beeae678d557017bad 100644
--- a/test/fuzztest/svcrestoredepsmanager_fuzzer/svcrestoredepsmanager_fuzzer.cpp
+++ b/test/fuzztest/svcrestoredepsmanager_fuzzer/svcrestoredepsmanager_fuzzer.cpp
@@ -57,16 +57,19 @@ void GetInfo(const uint8_t *data, size_t size, vector<BJsonEntityCaps::BundleInf
         pos += len;
         bundleInfo.supportScene = string(reinterpret_cast<const char*>(data + pos), len) + to_string(i);
 
-        if (size >= sizeof(bool)) {
-            bundleInfo.allToBackup = *(reinterpret_cast<const bool*>(data));
+        pos += len;
+        if (size >= pos + sizeof(bool)) {
+            bundleInfo.allToBackup = *(reinterpret_cast<const bool*>(data + pos));
         }
 
-        if (size >= sizeof(int64_t)) {
-            bundleInfo.versionCode = *(reinterpret_cast<const int64_t*>(data));
+        pos += sizeof(bool);
+        if (size >= pos + sizeof(int64_t)) {
+            bundleInfo.versionCode = *(reinterpret_cast<const int64_t*>(data + pos));
         }
 
-        if (size >= sizeof(int64_t)) {
-            bundleInfo.spaceOccupied = *(reinterpret_cast<const int64_t*>(data));
+        pos += sizeof(int64_t);
+        if (size >= pos + sizeof(int64_t)) {
+            bundleInfo.spaceOccupied = *(reinterpret_cast<const int64_t*>(data + pos));
         }
         info.push_back(bundleInfo);
     }
diff --git a/tests/unittests/backup_ext/tar_file_sub_test.cpp b/tests/unittests/backup_ext/tar_file_sub_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..864bb2a9deee4ad70766291e1b65fa2339fe3691
--- /dev/null
+++ b/tests/unittests/backup_ext/tar_file_sub_test.cpp
@@ -0,0 +1,115 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include <dirent.h>
+#include <fcntl.h>
+#include <grp.h>
+#include <pwd.h>
+#include <stack>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include "b_anony/b_anony.h"
+#include "b_error/b_error.h"
+#include "b_hiaudit/hi_audit.h"
+#include "b_resources/b_constants.h"
+#include "directory_ex.h"
+#include "filemgmt_libhilog.h"
+#include "library_func_mock.h"
+#include "securec.h"
+#include "tar_file.h"
+
+#include "library_func_define.h"
+#include "tar_file.cpp"
+#include "library_func_undef.h"
+
+namespace OHOS::FileManagement::Backup {
+using namespace std;
+using namespace testing;
+using namespace OHOS::AppFileService;
+
+class TarFileSubTest : public testing::Test {
+public:
+    static void SetUpTestCase(void);
+    static void TearDownTestCase();
+    void SetUp() override {};
+    void TearDown() override {};
+    static inline shared_ptr<LibraryFuncMock> funcMock = nullptr;
+};
+
+void TarFileSubTest::SetUpTestCase()
+{
+    GTEST_LOG_(INFO) << "SetUpTestCase enter";
+    funcMock = make_shared<LibraryFuncMock>();
+    LibraryFuncMock::libraryFunc_ = funcMock;
+}
+
+void TarFileSubTest::TearDownTestCase()
+{
+    GTEST_LOG_(INFO) << "TearDownTestCase enter";
+    LibraryFuncMock::libraryFunc_ = nullptr;
+    funcMock = nullptr;
+}
+
+/**
+ * @tc.number: SUB_Tar_File_CopyData_0100
+ * @tc.name: SUB_Tar_File_CopyData_0100
+ * @tc.desc: 测试 CopyData 接口
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: I6F3GV
+ */
+HWTEST_F(TarFileSubTest, SUB_Tar_File_CopyData_0100, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "TarFileSubTest-begin SUB_Tar_File_CopyData_0100";
+    try {
+        TarHeader hdr;
+        string mode;
+        string uid;
+        string gid;
+        string size;
+
+        EXPECT_CALL(*funcMock, memcpy_s(_, _, _, _)).WillOnce(Return(-1));
+        auto ret = CopyData(hdr, mode, uid, gid, size);
+        EXPECT_FALSE(ret);
+
+        EXPECT_CALL(*funcMock, memcpy_s(_, _, _, _)).WillOnce(Return(EOK)).WillOnce(Return(-1));
+        ret = CopyData(hdr, mode, uid, gid, size);
+        EXPECT_FALSE(ret);
+
+        EXPECT_CALL(*funcMock, memcpy_s(_, _, _, _)).WillOnce(Return(EOK)).WillOnce(Return(EOK)).WillOnce(Return(-1));
+        ret = CopyData(hdr, mode, uid, gid, size);
+        EXPECT_FALSE(ret);
+
+        EXPECT_CALL(*funcMock, memcpy_s(_, _, _, _)).WillOnce(Return(EOK)).WillOnce(Return(EOK)).WillOnce(Return(EOK))
+            .WillOnce(Return(-1));
+        ret = CopyData(hdr, mode, uid, gid, size);
+        EXPECT_FALSE(ret);
+
+        EXPECT_CALL(*funcMock, memcpy_s(_, _, _, _)).WillOnce(Return(EOK)).WillOnce(Return(EOK)).WillOnce(Return(EOK))
+            .WillOnce(Return(0));
+        ret = CopyData(hdr, mode, uid, gid, size);
+        EXPECT_TRUE(ret);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "TarFileSubTest-an exception occurred by TarFile.";
+    }
+    GTEST_LOG_(INFO) << "TarFileSubTest-end SUB_Tar_File_CopyData_0100";
+}
+} // namespace OHOS::FileManagement::Backup
\ No newline at end of file
diff --git a/tests/unittests/backup_ext/untar_file_sup_test.cpp b/tests/unittests/backup_ext/untar_file_sup_test.cpp
index 2d537fa1478d66bb4e753aec4ab1a217576c2992..ba695a52c4ae04f24e733e5c9f8aa07afb030294 100644
--- a/tests/unittests/backup_ext/untar_file_sup_test.cpp
+++ b/tests/unittests/backup_ext/untar_file_sup_test.cpp
@@ -789,4 +789,396 @@ HWTEST_F(UntarFileSupTest, SUB_Untar_File_UnPacket_0100, testing::ext::TestSize.
     }
     GTEST_LOG_(INFO) << "UntarFileSupTest-end SUB_Untar_File_UnPacket_0100";
 }
+
+/**
+ * @tc.number: SUB_Untar_File_IncrementalUnPacket_0100
+ * @tc.name: SUB_Untar_File_IncrementalUnPacket_0100
+ * @tc.desc: 测试 IncrementalUnPacket 接口
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: I6F3GV
+ */
+HWTEST_F(UntarFileSupTest, SUB_Untar_File_IncrementalUnPacket_0100, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "UntarFileSupTest-begin SUB_Untar_File_IncrementalUnPacket_0100";
+    try {
+        string tarFile;
+        string rootPath;
+        errno = EPERM;
+        unordered_map<string, struct ReportFileInfo> includes;
+        EXPECT_CALL(*funcMock, fopen(_, _)).WillOnce(Return(nullptr));
+        auto [ret, info, err] = UntarFile::GetInstance().IncrementalUnPacket(tarFile, rootPath, includes);
+        EXPECT_EQ(ret, EPERM);
+
+        char c = '\0';
+        EXPECT_CALL(*funcMock, fopen(_, _)).WillOnce(Return(reinterpret_cast<FILE*>(&c)));
+        EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(0)).WillOnce(Return(1));
+        EXPECT_CALL(*funcMock, ftello(_)).WillOnce(Return(0));
+        EXPECT_CALL(*funcMock, fclose(_)).WillOnce(Return(0));
+        tie(ret, info, err) = UntarFile::GetInstance().IncrementalUnPacket(tarFile, rootPath, includes);
+        EXPECT_EQ(ret, 0);
+
+        EXPECT_CALL(*funcMock, fopen(_, _)).WillOnce(Return(reinterpret_cast<FILE*>(&c)));
+        EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(0)).WillOnce(Return(0));
+        EXPECT_CALL(*funcMock, ftello(_)).WillOnce(Return(0));
+        EXPECT_CALL(*funcMock, fread(_, _, _, _)).WillOnce(Return(0));
+        EXPECT_CALL(*funcMock, fclose(_)).WillOnce(Return(0));
+        tie(ret, info, err) = UntarFile::GetInstance().IncrementalUnPacket(tarFile, rootPath, includes);
+        EXPECT_EQ(ret, 0);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "UntarFileSupTest-an exception occurred by IncrementalUnPacket.";
+    }
+    GTEST_LOG_(INFO) << "UntarFileSupTest-end SUB_Untar_File_IncrementalUnPacket_0100";
+}
+
+[[maybe_unused]] static off_t CalcChecksum(TarHeader &header)
+{
+    vector<uint8_t> buffer {};
+    buffer.resize(sizeof(header));
+    buffer.assign(reinterpret_cast<uint8_t *>(&header), reinterpret_cast<uint8_t *>(&header) + sizeof(header));
+    off_t sum = 0;
+    for (uint32_t index = 0; index < BLOCK_SIZE; ++index) {
+        if (index < CHKSUM_BASE || index > CHKSUM_BASE + CHKSUM_LEN - 1) {
+            // Standard tar checksum adds unsigned bytes.
+            sum += (buffer[index] & 0xFF);
+        } else {
+            sum += BLANK_SPACE;
+        }
+    }
+    return sum;
+}
+
+/**
+ * @tc.number: SUB_Untar_File_ParseTarFile_0100
+ * @tc.name: SUB_Untar_File_ParseTarFile_0100
+ * @tc.desc: 测试 ParseTarFile 接口
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: I6F3GV
+ */
+HWTEST_F(UntarFileSupTest, SUB_Untar_File_ParseTarFile_0100, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "UntarFileSupTest-begin SUB_Untar_File_ParseTarFile_0100";
+    try {
+        string tarFile;
+        string rootPath;
+        errno = EPERM;
+        EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(errno));
+        auto [ret, info, err] = UntarFile::GetInstance().ParseTarFile(rootPath);
+        EXPECT_EQ(ret, EPERM);
+
+        EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(0)).WillOnce(Return(0));
+        EXPECT_CALL(*funcMock, ftello(_)).WillOnce(Return(0));
+        EXPECT_CALL(*funcMock, fread(_, _, _, _)).WillOnce(Return(0));
+        tie(ret, info, err) = UntarFile::GetInstance().ParseTarFile(rootPath);
+        EXPECT_EQ(ret, 0);
+
+        EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(0)).WillOnce(Return(0));
+        EXPECT_CALL(*funcMock, ftello(_)).WillOnce(Return(0));
+        EXPECT_CALL(*funcMock, fread(_, _, _, _)).WillOnce(Return(BLOCK_SIZE)).WillOnce(Return(BLOCK_SIZE));
+        tie(ret, info, err) = UntarFile::GetInstance().ParseTarFile(rootPath);
+        EXPECT_EQ(ret, 0);
+
+        string sum = "01647";
+        TarHeader header;
+        header.typeFlag = 'x';
+        memcpy_s(&header.magic, sizeof(header.magic), TMAGIC.c_str(), TMAGIC.length());
+        memcpy_s(&header.chksum, sizeof(header.chksum), sum.c_str(), sum.length());
+        EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(0)).WillOnce(Return(0)).WillOnce(Return(EPERM));
+        EXPECT_CALL(*funcMock, ftello(_)).WillOnce(Return(0)).WillOnce(Return(0));
+        EXPECT_CALL(*funcMock, fread(_, _, _, _)).WillOnce(WithArgs<0>(Invoke([&header](void* buff) {
+            memcpy_s(buff, BLOCK_SIZE, &header, sizeof(header));
+            return BLOCK_SIZE;
+        }))).WillOnce(Return(0));
+        tie(ret, info, err) = UntarFile::GetInstance().ParseTarFile(rootPath);
+        EXPECT_EQ(ret, DEFAULT_ERR);
+
+        EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(0)).WillOnce(Return(0)).WillOnce(Return(0));
+        EXPECT_CALL(*funcMock, ftello(_)).WillOnce(Return(0)).WillOnce(Return(0));
+        EXPECT_CALL(*funcMock, fread(_, _, _, _)).WillOnce(WithArgs<0>(Invoke([&header](void* buff) {
+            memcpy_s(buff, BLOCK_SIZE, &header, sizeof(header));
+            return BLOCK_SIZE;
+        }))).WillOnce(Return(0)).WillOnce(Return(0));
+        tie(ret, info, err) = UntarFile::GetInstance().ParseTarFile(rootPath);
+        EXPECT_EQ(ret, 0);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "UntarFileSupTest-an exception occurred by ParseTarFile.";
+    }
+    GTEST_LOG_(INFO) << "UntarFileSupTest-end SUB_Untar_File_ParseTarFile_0100";
+}
+
+/**
+ * @tc.number: SUB_Untar_File_ParseIncrementalTarFile_0100
+ * @tc.name: SUB_Untar_File_ParseIncrementalTarFile_0100
+ * @tc.desc: 测试 ParseIncrementalTarFile 接口
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: I6F3GV
+ */
+HWTEST_F(UntarFileSupTest, SUB_Untar_File_ParseIncrementalTarFile_0100, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "UntarFileSupTest-begin SUB_Untar_File_ParseIncrementalTarFile_0100";
+    try {
+        string tarFile;
+        string rootPath;
+        errno = EPERM;
+        EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(errno));
+        auto [ret, info, err] = UntarFile::GetInstance().ParseIncrementalTarFile(rootPath);
+        EXPECT_EQ(ret, EPERM);
+
+        EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(0)).WillOnce(Return(0));
+        EXPECT_CALL(*funcMock, ftello(_)).WillOnce(Return(0));
+        EXPECT_CALL(*funcMock, fread(_, _, _, _)).WillOnce(Return(0));
+        tie(ret, info, err) = UntarFile::GetInstance().ParseIncrementalTarFile(rootPath);
+        EXPECT_EQ(ret, 0);
+
+        EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(0)).WillOnce(Return(0));
+        EXPECT_CALL(*funcMock, ftello(_)).WillOnce(Return(0));
+        EXPECT_CALL(*funcMock, fread(_, _, _, _)).WillOnce(Return(BLOCK_SIZE)).WillOnce(Return(BLOCK_SIZE));
+        tie(ret, info, err) = UntarFile::GetInstance().ParseIncrementalTarFile(rootPath);
+        EXPECT_EQ(ret, 0);
+
+        string sum = "01647";
+        TarHeader header;
+        header.typeFlag = 'x';
+        memcpy_s(&header.magic, sizeof(header.magic), TMAGIC.c_str(), TMAGIC.length());
+        memcpy_s(&header.chksum, sizeof(header.chksum), sum.c_str(), sum.length());
+        EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(0)).WillOnce(Return(0)).WillOnce(Return(EPERM));
+        EXPECT_CALL(*funcMock, ftello(_)).WillOnce(Return(0)).WillOnce(Return(0));
+        EXPECT_CALL(*funcMock, fread(_, _, _, _)).WillOnce(WithArgs<0>(Invoke([&header](void* buff) {
+            memcpy_s(buff, BLOCK_SIZE, &header, sizeof(header));
+            return BLOCK_SIZE;
+        }))).WillOnce(Return(0));
+        tie(ret, info, err) = UntarFile::GetInstance().ParseIncrementalTarFile(rootPath);
+        EXPECT_EQ(ret, DEFAULT_ERR);
+
+        EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(0)).WillOnce(Return(0)).WillOnce(Return(0));
+        EXPECT_CALL(*funcMock, ftello(_)).WillOnce(Return(0)).WillOnce(Return(0));
+        EXPECT_CALL(*funcMock, fread(_, _, _, _)).WillOnce(WithArgs<0>(Invoke([&header](void* buff) {
+            memcpy_s(buff, BLOCK_SIZE, &header, sizeof(header));
+            return BLOCK_SIZE;
+        }))).WillOnce(Return(0)).WillOnce(Return(0));
+        tie(ret, info, err) = UntarFile::GetInstance().ParseIncrementalTarFile(rootPath);
+        EXPECT_EQ(ret, 0);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "UntarFileSupTest-an exception occurred by ParseIncrementalTarFile.";
+    }
+    GTEST_LOG_(INFO) << "UntarFileSupTest-end SUB_Untar_File_ParseIncrementalTarFile_0100";
+}
+
+/**
+ * @tc.number: SUB_Untar_File_HandleTarBuffer_0100
+ * @tc.name: SUB_Untar_File_HandleTarBuffer_0100
+ * @tc.desc: 测试 HandleTarBuffer 接口
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: I6F3GV
+ */
+HWTEST_F(UntarFileSupTest, SUB_Untar_File_HandleTarBuffer_0100, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "UntarFileSupTest-begin SUB_Untar_File_HandleTarBuffer_0100";
+    try {
+        char buff[BLOCK_SIZE] = {0};
+        string name;
+        FileStatInfo info;
+        EXPECT_CALL(*funcMock, ftello(_)).WillOnce(Return(0));
+        auto ret = UntarFile::GetInstance().HandleTarBuffer(buff, name, info);
+        EXPECT_EQ(ret, 0);
+
+        info.longName = "longName";
+        EXPECT_CALL(*funcMock, ftello(_)).WillOnce(Return(0));
+        ret = UntarFile::GetInstance().HandleTarBuffer(buff, name, info);
+        EXPECT_EQ(ret, 0);
+
+        name = "name";
+        EXPECT_CALL(*funcMock, ftello(_)).WillOnce(Return(0));
+        ret = UntarFile::GetInstance().HandleTarBuffer(buff, name, info);
+        EXPECT_EQ(ret, 0);
+
+        name = "/name";
+        EXPECT_CALL(*funcMock, ftello(_)).WillOnce(Return(0));
+        ret = UntarFile::GetInstance().HandleTarBuffer(buff, name, info);
+        EXPECT_EQ(ret, 0);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "UntarFileSupTest-an exception occurred by HandleTarBuffer.";
+    }
+    GTEST_LOG_(INFO) << "UntarFileSupTest-end SUB_Untar_File_HandleTarBuffer_0100";
+}
+
+/**
+ * @tc.number: SUB_Untar_File_CheckAndFillTarSize_0100
+ * @tc.name: SUB_Untar_File_CheckAndFillTarSize_0100
+ * @tc.desc: 测试 CheckAndFillTarSize 接口
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: I6F3GV
+ */
+HWTEST_F(UntarFileSupTest, SUB_Untar_File_CheckAndFillTarSize_0100, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "UntarFileSupTest-begin SUB_Untar_File_CheckAndFillTarSize_0100";
+    try {
+        EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(EPERM));
+        auto ret = UntarFile::GetInstance().CheckAndFillTarSize();
+        EXPECT_EQ(ret, EPERM);
+
+        EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(0)).WillOnce(Return(EPERM));
+        EXPECT_CALL(*funcMock, ftello(_)).WillOnce(Return(0));
+        ret = UntarFile::GetInstance().CheckAndFillTarSize();
+        EXPECT_EQ(ret, EPERM);
+
+        EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(0)).WillOnce(Return(0));
+        EXPECT_CALL(*funcMock, ftello(_)).WillOnce(Return(0));
+        ret = UntarFile::GetInstance().CheckAndFillTarSize();
+        EXPECT_EQ(ret, 0);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "UntarFileSupTest-an exception occurred by CheckAndFillTarSize.";
+    }
+    GTEST_LOG_(INFO) << "UntarFileSupTest-end SUB_Untar_File_CheckAndFillTarSize_0100";
+}
+
+/**
+ * @tc.number: SUB_Untar_File_DealParseTarFileResult_0100
+ * @tc.name: SUB_Untar_File_DealParseTarFileResult_0100
+ * @tc.desc: 测试 DealParseTarFileResult 接口
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: I6F3GV
+ */
+HWTEST_F(UntarFileSupTest, SUB_Untar_File_DealParseTarFileResult_0100, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "UntarFileSupTest-begin SUB_Untar_File_DealParseTarFileResult_0100";
+    try {
+        string fileName;
+        EndFileInfo fileInfos;
+        ErrFileInfo errs;
+        ErrFileInfo errInfos;
+        tuple<int, bool, ErrFileInfo> result {EPERM, false, errs};
+        auto ret = UntarFile::GetInstance().DealParseTarFileResult(result, 0, fileName, fileInfos, errInfos);
+        EXPECT_EQ(ret, EPERM);
+
+        std::get<0>(result) = 0;
+        ret = UntarFile::GetInstance().DealParseTarFileResult(result, 1, fileName, fileInfos, errInfos);
+        EXPECT_EQ(fileInfos[fileName], 1);
+        EXPECT_EQ(ret, 0);
+
+        std::get<1>(result) = true;
+        ret = UntarFile::GetInstance().DealParseTarFileResult(result, 0, fileName, fileInfos, errInfos);
+        EXPECT_EQ(errInfos.size(), 0);
+        EXPECT_EQ(ret, 0);
+
+        std::get<2>(result)["errno"] = {-1};
+        errInfos.emplace("err", 0);
+        ret = UntarFile::GetInstance().DealParseTarFileResult(result, 0, fileName, fileInfos, errInfos);
+        EXPECT_EQ(errInfos.size(), 2);
+        EXPECT_EQ(ret, 0);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "UntarFileSupTest-an exception occurred by DealParseTarFileResult.";
+    }
+    GTEST_LOG_(INFO) << "UntarFileSupTest-end SUB_Untar_File_DealParseTarFileResult_0100";
+}
+
+/**
+ * @tc.number: SUB_Untar_File_DealIncreParseTarFileResult_0100
+ * @tc.name: SUB_Untar_File_DealIncreParseTarFileResult_0100
+ * @tc.desc: 测试 DealIncreParseTarFileResult 接口
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: I6F3GV
+ */
+HWTEST_F(UntarFileSupTest, SUB_Untar_File_DealIncreParseTarFileResult_0100, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "UntarFileSupTest-begin SUB_Untar_File_DealIncreParseTarFileResult_0100";
+    try {
+        string fileName;
+        EndFileInfo fileInfos;
+        ErrFileInfo errs;
+        ErrFileInfo errInfos;
+        tuple<int, bool, ErrFileInfo> result {EPERM, false, errs};
+        auto ret = UntarFile::GetInstance().DealIncreParseTarFileResult(result, 0, fileName, fileInfos, errInfos);
+        EXPECT_EQ(ret, EPERM);
+
+        std::get<0>(result) = 0;
+        ret = UntarFile::GetInstance().DealIncreParseTarFileResult(result, 1, fileName, fileInfos, errInfos);
+        EXPECT_EQ(fileInfos[fileName], 1);
+        EXPECT_EQ(ret, 0);
+
+        std::get<1>(result) = true;
+        ret = UntarFile::GetInstance().DealIncreParseTarFileResult(result, 0, fileName, fileInfos, errInfos);
+        EXPECT_EQ(errInfos.size(), 0);
+        EXPECT_EQ(ret, 0);
+
+        std::get<2>(result)["errno"] = {-1};
+        errInfos.emplace("err", 0);
+        ret = UntarFile::GetInstance().DealIncreParseTarFileResult(result, 0, fileName, fileInfos, errInfos);
+        EXPECT_EQ(errInfos.size(), 2);
+        EXPECT_EQ(ret, 0);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "UntarFileSupTest-an exception occurred by DealIncreParseTarFileResult.";
+    }
+    GTEST_LOG_(INFO) << "UntarFileSupTest-end SUB_Untar_File_DealIncreParseTarFileResult_0100";
+}
+
+/**
+ * @tc.number: SUB_Untar_File_CreateFile_0100
+ * @tc.name: SUB_Untar_File_CreateFile_0100
+ * @tc.desc: 测试 CreateFile 接口
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: I6F3GV
+ */
+HWTEST_F(UntarFileSupTest, SUB_Untar_File_CreateFile_0100, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "UntarFileSupTest-begin SUB_Untar_File_CreateFile_0100";
+    try {
+        char c = '\0';
+        string filePath;
+        EXPECT_CALL(*funcMock, realpath(_, _)).WillOnce(Return(&c));
+        EXPECT_CALL(*funcMock, fopen(_, _)).WillOnce(Return(nullptr));
+        auto ret = UntarFile::GetInstance().CreateFile(filePath);
+        EXPECT_TRUE(ret == nullptr);
+
+        EXPECT_CALL(*funcMock, realpath(_, _)).WillOnce(Return(&c));
+        EXPECT_CALL(*funcMock, fopen(_, _)).WillOnce(Return(reinterpret_cast<FILE*>(&c)));
+        ret = UntarFile::GetInstance().CreateFile(filePath);
+        EXPECT_TRUE(ret != nullptr);
+
+        EXPECT_CALL(*funcMock, realpath(_, _)).WillOnce(Return(nullptr));
+        ret = UntarFile::GetInstance().CreateFile(filePath);
+        EXPECT_TRUE(ret == nullptr);
+
+        filePath = "./test.txt";
+        EXPECT_CALL(*funcMock, realpath(_, _)).WillOnce(Return(nullptr)).WillOnce(Return(nullptr));
+        ret = UntarFile::GetInstance().CreateFile(filePath);
+        EXPECT_TRUE(ret == nullptr);
+
+        EXPECT_CALL(*funcMock, realpath(_, _)).WillOnce(Return(nullptr)).WillOnce(Return(&c));
+        EXPECT_CALL(*funcMock, fopen(_, _)).WillOnce(Return(nullptr));
+        ret = UntarFile::GetInstance().CreateFile(filePath);
+        EXPECT_TRUE(ret == nullptr);
+
+        EXPECT_CALL(*funcMock, realpath(_, _)).WillOnce(Return(nullptr)).WillOnce(Return(&c));
+        EXPECT_CALL(*funcMock, fopen(_, _)).WillOnce(Return(reinterpret_cast<FILE*>(&c)));
+        ret = UntarFile::GetInstance().CreateFile(filePath);
+        EXPECT_TRUE(ret != nullptr);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "UntarFileSupTest-an exception occurred by CreateFile.";
+    }
+    GTEST_LOG_(INFO) << "UntarFileSupTest-end SUB_Untar_File_CreateFile_0100";
+}
 } // namespace OHOS::FileManagement::Backup
\ No newline at end of file