diff --git a/tests/unittests/backup_tools/BUILD.gn b/tests/unittests/backup_tools/BUILD.gn
index 636eef0039b303972f34804596889318973ca3c5..de9ac444293c17ae4eab668a24b25f9482d1c7aa 100644
--- a/tests/unittests/backup_tools/BUILD.gn
+++ b/tests/unittests/backup_tools/BUILD.gn
@@ -23,9 +23,11 @@ ohos_unittest("backup_tool_test") {
     "${path_backup}/tools/backup_tool/src/tools_op.cpp",
     "${path_backup}/tools/backup_tool/src/tools_op_backup.cpp",
     "${path_backup}/tools/backup_tool/src/tools_op_check_sa.cpp",
+    "${path_backup}/tools/backup_tool/src/tools_op_help.cpp",
     "backup_tool/tools_op_backup_test.cpp",
     "backup_tool/tools_op_check_sa_test.cpp",
     "backup_tool/tools_op_test.cpp",
+    "backup_tool/tools_op_help_test.cpp",
   ]
   sources += backup_mock_proxy_src
 
@@ -51,6 +53,13 @@ ohos_unittest("backup_tool_test") {
     "ipc:ipc_core",
     "samgr:samgr_proxy",
   ]
+
+  sanitize = {
+    cfi = true
+    cfi_cross_dso = true
+    debug = false
+  }
+
   use_exceptions = true
 }
 
@@ -91,6 +100,13 @@ ohos_unittest("backup_tool_restore_test") {
     "ipc:ipc_core",
     "samgr:samgr_proxy",
   ]
+
+  sanitize = {
+    cfi = true
+    cfi_cross_dso = true
+    debug = false
+  }
+
   use_exceptions = true
 }
 
diff --git a/tests/unittests/backup_tools/backup_tool/tools_op_backup_test.cpp b/tests/unittests/backup_tools/backup_tool/tools_op_backup_test.cpp
index fd759abc1e8b2cb76e80abce36c6a73575bd919f..bad2adbd4b24a4e78dcccd4c969fa6e5d871106e 100644
--- a/tests/unittests/backup_tools/backup_tool/tools_op_backup_test.cpp
+++ b/tests/unittests/backup_tools/backup_tool/tools_op_backup_test.cpp
@@ -21,6 +21,7 @@
 
 #include "b_resources/b_constants.h"
 #include "tools_op.h"
+#include "tools_op_backup.h"
 #include "utils_mock_global_variable.h"
 
 namespace OHOS::FileManagement::Backup {
@@ -46,6 +47,7 @@ HWTEST_F(ToolsOpBackupTest, SUB_backup_tools_op_backup_0100, testing::ext::TestS
 {
     GTEST_LOG_(INFO) << "ToolsOpBackupTest-begin SUB_backup_tools_op_backup_0100";
     try {
+        BackUpRegister(); 
         SetMockGetInstance(true);
         GTEST_LOG_(INFO) << "ToolsOpBackupTest-info";
         map<string, vector<string>> mapArgToVal;
@@ -107,7 +109,7 @@ HWTEST_F(ToolsOpBackupTest, SUB_backup_tools_op_backup_0200, testing::ext::TestS
             EXPECT_NE(ret, 0);
         }
 
-        GTEST_LOG_(INFO) << "ToolsOpBackupTest-The bundles field is noGt contained.";
+        GTEST_LOG_(INFO) << "ToolsOpBackupTest-The bundles field is not contained.";
         mapArgToVal.clear();
         mapArgToVal.insert(make_pair("pathCapFile", path));
         mapArgToVal.insert(make_pair("isLocal", local));
@@ -116,7 +118,7 @@ HWTEST_F(ToolsOpBackupTest, SUB_backup_tools_op_backup_0200, testing::ext::TestS
             EXPECT_NE(ret, 0);
         }
 
-        GTEST_LOG_(INFO) << "ToolsOpBackupTest-The isLocal field is noGt contained.";
+        GTEST_LOG_(INFO) << "ToolsOpBackupTest-The isLocal field is not contained.";
         mapArgToVal.clear();
         mapArgToVal.insert(make_pair("pathCapFile", path));
         mapArgToVal.insert(make_pair("bundles", bundles));
@@ -125,6 +127,26 @@ HWTEST_F(ToolsOpBackupTest, SUB_backup_tools_op_backup_0200, testing::ext::TestS
             EXPECT_NE(ret, 0);
         }
 
+        mapArgToVal.clear();
+        path.clear();
+        mapArgToVal.insert(make_pair("pathCapFile", path));
+        mapArgToVal.insert(make_pair("bundles", bundles));
+        mapArgToVal.insert(make_pair("isLocal", local));
+        if (matchedOp != opeartions.end()) {
+            ret = matchedOp->Execute(mapArgToVal);
+            EXPECT_NE(ret, 0);
+        }
+
+        mapArgToVal.clear();
+        vector<string> bundlesNotExist = {"com.example.xxxxxxx"};
+        mapArgToVal.insert(make_pair("pathCapFile", path));
+        mapArgToVal.insert(make_pair("bundles", bundlesNotExist));
+        mapArgToVal.insert(make_pair("isLocal", local));
+        if (matchedOp != opeartions.end()) {
+            ret = matchedOp->Execute(mapArgToVal);
+            EXPECT_NE(ret, 0);
+        }
+
         mapArgToVal.clear();
         if (matchedOp != opeartions.end()) {
             ret = matchedOp->Execute(mapArgToVal);
@@ -151,6 +173,7 @@ HWTEST_F(ToolsOpBackupTest, SUB_backup_tools_op_backup_0300, testing::ext::TestS
     GTEST_LOG_(INFO) << "ToolsOpBackupTest-begin SUB_backup_tools_op_backup_0300";
     try {
         GTEST_LOG_(INFO) << "ToolsOpBackupTest-info";
+        BackUpRegister();
         map<string, vector<string>> mapArgToVal;
         vector<string> path = {"/data/backup/tmp"};
         mapArgToVal.insert(make_pair("pathCapFile", path));
@@ -176,4 +199,259 @@ HWTEST_F(ToolsOpBackupTest, SUB_backup_tools_op_backup_0300, testing::ext::TestS
     }
     GTEST_LOG_(INFO) << "ToolsOpBackupTest-end SUB_backup_tools_op_backup_0300";
 }
+
+/**
+ * @tc.number: SUB_backup_tools_op_backup_0400
+ * @tc.name: SUB_backup_tools_op_backup_0400
+ * @tc.desc: 测试InitPathCapFile分支
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: I6F3GV
+ */
+HWTEST_F(ToolsOpBackupTest, SUB_backup_tools_op_backup_0400, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "ToolsOpBackupTest-begin SUB_backup_tools_op_backup_0400";
+    try {
+        GTEST_LOG_(INFO) << "ToolsOpBackupTest-info";
+        BackUpRegister();
+        map<string, vector<string>> mapArgToVal;
+        vector<string> path = {"/data/backup/tmp"};
+        mapArgToVal.insert(make_pair("pathCapFile", path));
+        vector<string> bundles = {""};
+        mapArgToVal.insert(make_pair("bundles", bundles));
+        vector<string> local = {"false"};
+        mapArgToVal.insert(make_pair("isLocal", local));
+
+        // 尝试匹配当前命令，成功后执行
+        GTEST_LOG_(INFO) << "ToolsOpBackupTest-backup";
+        vector<string_view> curOp;
+        curOp.emplace_back("backup");
+        auto tryOpSucceed = [&curOp](const ToolsOp &op) { return op.TryMatch(curOp); };
+        auto &&opeartions = ToolsOp::GetAllOperations();
+        auto matchedOp = find_if(opeartions.begin(), opeartions.end(), tryOpSucceed);
+        if (matchedOp != opeartions.end()) {
+            auto ret = matchedOp->Execute(mapArgToVal);
+            EXPECT_EQ(ret, 0);
+        }
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "ToolsOpBackupTest-an exception occurred by construction.";
+    }
+    GTEST_LOG_(INFO) << "ToolsOpBackupTest-end SUB_backup_tools_op_backup_0400";
+}
+
+/**
+ * @tc.number: SUB_backup_tools_op_backup_0500
+ * @tc.name: SUB_backup_tools_op_backup_0500
+ * @tc.desc: 测试OnAllBundlesFinished分支
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: I6F3GV
+ */
+HWTEST_F(ToolsOpBackupTest, SUB_backup_tools_op_backup_0500, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "ToolsOpBackupTest-begin SUB_backup_tools_op_backup_0500";
+    try {
+        GTEST_LOG_(INFO) << "ToolsOpBackupTest-info";
+        BackUpRegister();
+        map<string, vector<string>> mapArgToVal;
+        vector<string> path = {"/data/backup/tmp"};
+        mapArgToVal.insert(make_pair("pathCapFile", path));
+        vector<string> bundles = {"com.example.app2backup"};
+        mapArgToVal.insert(make_pair("bundles", bundles));
+        vector<string> local = {"false"};
+        mapArgToVal.insert(make_pair("isLocal", local));
+
+        // 尝试匹配当前命令，成功后执行
+        GTEST_LOG_(INFO) << "ToolsOpBackupTest-backup";
+        vector<string_view> curOp;
+        curOp.emplace_back("backup");
+        auto tryOpSucceed = [&curOp](const ToolsOp &op) { return op.TryMatch(curOp); };
+        auto &&opeartions = ToolsOp::GetAllOperations();
+        auto matchedOp = find_if(opeartions.begin(), opeartions.end(), tryOpSucceed);
+        if (matchedOp != opeartions.end()) {
+            auto ret = matchedOp->Execute(mapArgToVal);
+            EXPECT_EQ(ret, 0);
+        }
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "ToolsOpBackupTest-an exception occurred by construction.";
+    }
+    GTEST_LOG_(INFO) << "ToolsOpBackupTest-end SUB_backup_tools_op_backup_0500";
+}
+
+/**
+ * @tc.number: SUB_backup_tools_op_backup_0600
+ * @tc.name: SUB_backup_tools_op_backup_0600
+ * @tc.desc: 测试InitPathCapFile分支
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: I6F3GV
+ */
+HWTEST_F(ToolsOpBackupTest, SUB_backup_tools_op_backup_0600, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "ToolsOpBackupTest-begin SUB_backup_tools_op_backup_0600";
+    try {
+        GTEST_LOG_(INFO) << "ToolsOpBackupTest-info";
+        BackUpRegister();
+        rmdir((BConstants::BACKUP_TOOL_LINK_DIR).data());
+        mkdir((BConstants::BACKUP_TOOL_LINK_DIR).data(), S_IRWXO);
+        map<string, vector<string>> mapArgToVal;
+        vector<string> path = {"/data/backup/tmp"};
+        mapArgToVal.insert(make_pair("pathCapFile", path));
+        vector<string> bundles = {"com.example.app2backup"};
+        mapArgToVal.insert(make_pair("bundles", bundles));
+        vector<string> local = {"false"};
+        mapArgToVal.insert(make_pair("isLocal", local));
+
+        // 尝试匹配当前命令，成功后执行
+        GTEST_LOG_(INFO) << "ToolsOpBackupTest-backup";
+        vector<string_view> curOp;
+        curOp.emplace_back("backup");
+        auto tryOpSucceed = [&curOp](const ToolsOp &op) { return op.TryMatch(curOp); };
+        auto &&opeartions = ToolsOp::GetAllOperations();
+        auto matchedOp = find_if(opeartions.begin(), opeartions.end(), tryOpSucceed);
+        if (matchedOp != opeartions.end()) {
+            auto ret = matchedOp->Execute(mapArgToVal);
+            EXPECT_EQ(ret, 0);
+        }
+        rmdir((BConstants::BACKUP_TOOL_LINK_DIR).data());
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "ToolsOpBackupTest-an exception occurred by construction.";
+    }
+    GTEST_LOG_(INFO) << "ToolsOpBackupTest-end SUB_backup_tools_op_backup_0600";
+}
+
+/**
+ * @tc.number: SUB_backup_tools_op_backup_0700
+ * @tc.name: SUB_backup_tools_op_backup_0700
+ * @tc.desc: 测试InitPathCapFile分支
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: I6F3GV
+ */
+HWTEST_F(ToolsOpBackupTest, SUB_backup_tools_op_backup_0700, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "ToolsOpBackupTest-begin SUB_backup_tools_op_backup_0700";
+    try {
+        GTEST_LOG_(INFO) << "ToolsOpBackupTest-info";
+        BackUpRegister();
+        map<string, vector<string>> mapArgToVal;
+        vector<string> path = {"/data/backup/tmp"};
+        mapArgToVal.insert(make_pair("pathCapFile", path));
+        vector<string> bundles = {"com.example.app2backup"};
+        mapArgToVal.insert(make_pair("bundles", bundles));
+        vector<string> local = {"false"};
+        mapArgToVal.insert(make_pair("isLocal", local));
+
+        // 尝试匹配当前命令，成功后执行
+        GTEST_LOG_(INFO) << "ToolsOpBackupTest-backup";
+        vector<string_view> curOp;
+        curOp.emplace_back("backup");
+        auto tryOpSucceed = [&curOp](const ToolsOp &op) { return op.TryMatch(curOp);};
+        auto &&opeartions = ToolsOp::GetAllOperations();
+        auto matchedOp = find_if(opeartions.begin(), opeartions.end(), tryOpSucceed);
+        if (matchedOp != opeartions.end()) {
+            auto ret = matchedOp->Execute(mapArgToVal);
+            EXPECT_EQ(ret, 0);
+        }
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "ToolsOpBackupTest-an exception occurred by construction.";
+    }
+    GTEST_LOG_(INFO) << "ToolsOpBackupTest-end SUB_backup_tools_op_backup_0700";
+}
+
+/**
+ * @tc.number: SUB_backup_tools_op_backup_0900
+ * @tc.name: SUB_backup_tools_op_backup_0900
+ * @tc.desc: 测试BackupToolDirSoftlinkToBackupDir分支
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: I6F3GV
+ */
+HWTEST_F(ToolsOpBackupTest, SUB_backup_tools_op_backup_0900, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "ToolsOpBackupTest-begin SUB_backup_tools_op_backup_0900";
+    try {
+        GTEST_LOG_(INFO) << "ToolsOpBackupTest-info";
+        BackUpRegister();
+        rmdir(BConstants::BACKUP_TOOL_LINK_DIR.data());
+        map<string, vector<string>> mapArgToVal;
+        vector<string> path = {"/data/backup/tmp"};
+        mapArgToVal.insert(make_pair("pathCapFile", path));
+        vector<string> bundles = {"com.example.app2backup"};
+        mapArgToVal.insert(make_pair("bundles", bundles));
+        vector<string> local = {"false"};
+        mapArgToVal.insert(make_pair("isLocal", local));
+
+        // 尝试匹配当前命令，成功后执行
+        GTEST_LOG_(INFO) << "ToolsOpBackupTest-backup";
+        vector<string_view> curOp;
+        curOp.emplace_back("backup");
+        auto tryOpSucceed = [&curOp](const ToolsOp &op) { return op.TryMatch(curOp); };
+        auto &&opeartions = ToolsOp::GetAllOperations();
+        auto matchedOp = find_if(opeartions.begin(), opeartions.end(), tryOpSucceed);
+        if (matchedOp != opeartions.end()) {
+            auto ret = matchedOp->Execute(mapArgToVal);
+            EXPECT_EQ(ret, 0);
+        }
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "ToolsOpBackupTest-an exception occurred by construction.";
+    }
+    GTEST_LOG_(INFO) << "ToolsOpBackupTest-end SUB_backup_tools_op_backup_0900";
+}
+
+
+
+/**
+ * @tc.number: SUB_backup_tools_op_backup_1000
+ * @tc.name: SUB_backup_tools_op_backup_1000
+ * @tc.desc: 测试InitPathCapFile分支
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: I6F3GV
+ */
+HWTEST_F(ToolsOpBackupTest, SUB_backup_tools_op_backup_1000, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "ToolsOpBackupTest-begin SUB_backup_tools_op_backup_1000";
+    try {
+        GTEST_LOG_(INFO) << "ToolsOpBackupTest-info";        
+        BackUpRegister();
+        string cmdusermod = string("usermod -u 1000") + BConstants::BACKUP_TOOL_RECEIVE_DIR.data();
+        system(cmdusermod.c_str());
+        map<string, vector<string>> mapArgToVal;
+        vector<string> path = {"/data/backup/tmp"};
+        mapArgToVal.insert(make_pair("pathCapFile", path));
+        vector<string> bundles = {"com.example.app2backup"};
+        mapArgToVal.insert(make_pair("bundles", bundles));
+        vector<string> local = {"false"};
+        mapArgToVal.insert(make_pair("isLocal", local));
+
+        // 尝试匹配当前命令，成功后执行
+        GTEST_LOG_(INFO) << "ToolsOpBackupTest-backup";
+        vector<string_view> curOp;
+        curOp.emplace_back("backup");
+        auto tryOpSucceed = [&curOp](const ToolsOp &op) { return op.TryMatch(curOp); };
+        auto &&opeartions = ToolsOp::GetAllOperations();
+        auto matchedOp = find_if(opeartions.begin(), opeartions.end(), tryOpSucceed);
+        if (matchedOp != opeartions.end()) {
+            auto ret = matchedOp->Execute(mapArgToVal);
+            EXPECT_EQ(ret, 0);
+        }
+        rmdir((BConstants::BACKUP_TOOL_RECEIVE_DIR).data());
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "ToolsOpBackupTest-an exception occurred by construction.";
+    }
+    GTEST_LOG_(INFO) << "ToolsOpBackupTest-end SUB_backup_tools_op_backup_1000";
+}
 } // namespace OHOS::FileManagement::Backup
\ No newline at end of file
diff --git a/tests/unittests/backup_tools/backup_tool/tools_op_check_sa_test.cpp b/tests/unittests/backup_tools/backup_tool/tools_op_check_sa_test.cpp
index 5e8fd4cedbe30845eee4d01727329c52397cc825..bead7b5dcb61971eea80a1edb0d629f2b76c1f73 100644
--- a/tests/unittests/backup_tools/backup_tool/tools_op_check_sa_test.cpp
+++ b/tests/unittests/backup_tools/backup_tool/tools_op_check_sa_test.cpp
@@ -19,6 +19,7 @@
 #include <sstream>
 
 #include "tools_op.h"
+#include "tools_op_check_sa.h"
 #include "utils_mock_global_variable.h"
 
 namespace OHOS::FileManagement::Backup {
@@ -69,4 +70,45 @@ HWTEST_F(ToolsOpCheckSaTest, SUB_backup_tools_op_check_sa_0100, testing::ext::Te
     }
     GTEST_LOG_(INFO) << "ToolsOpCheckSaTest-end SUB_backup_tools_op_check_sa_0100";
 }
+
+/**
+ * @tc.number: SUB_backup_tools_op_check_sa_0200
+ * @tc.name: SUB_backup_tools_op_check_sa_0200
+ * @tc.desc: 测试Exec
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: I6F3GV
+ */
+HWTEST_F(ToolsOpCheckSaTest, SUB_backup_tools_op_check_sa_0200, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "ToolsOpCheckSaTest-begin SUB_backup_tools_op_check_sa_0200";
+    try {
+        GTEST_LOG_(INFO) << "ToolsOpCheckSaTest-info";
+        map<string, vector<string>> mapArgToVal;
+        SetMockGetInstance(true);
+        vector<string_view> curOp;
+        curOp.emplace_back("check");
+        curOp.emplace_back("sa");
+        CheckSaRegister();
+        auto tryOpSucceed = [&curOp](const ToolsOp &op) { return op.TryMatch(curOp); };
+        auto &&opeartions = ToolsOp::GetAllOperations();
+        auto matchedOp = find_if(opeartions.begin(), opeartions.end(), tryOpSucceed);
+        int ret = 0;
+        if (matchedOp != opeartions.end()) {
+            ret = matchedOp->Execute(mapArgToVal);
+            EXPECT_EQ(ret, 0);
+        }
+        GTEST_LOG_(INFO) << "GetInstance is false";
+        SetMockGetInstance(false);
+        if (matchedOp != opeartions.end()) {
+            ret = matchedOp->Execute(mapArgToVal);
+            EXPECT_NE(ret, 0);
+        }
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "ToolsOpCheckSaTest-an exception occurred by construction.";
+    }
+    GTEST_LOG_(INFO) << "ToolsOpCheckSaTest-end SUB_backup_tools_op_check_sa_0200";
+}
 } // namespace OHOS::FileManagement::Backup
\ No newline at end of file
diff --git a/tests/unittests/backup_tools/backup_tool/tools_op_help_test.cpp b/tests/unittests/backup_tools/backup_tool/tools_op_help_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9b3e044367b900185b70d46972f49c67436e6897
--- /dev/null
+++ b/tests/unittests/backup_tools/backup_tool/tools_op_help_test.cpp
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2022-2023 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 <iostream>
+#include <map>
+#include <sstream>
+
+#include <gtest/gtest.h>
+#include "tools_op.h"
+#include "tools_op_help.h"
+
+namespace OHOS::FileManagement::Backup {
+using namespace std;
+class ToolsOpHelpTest : public testing::Test {
+public:
+    static void SetUpTestCase(void) {};
+    static void TearDownTestCase() {};
+    void SetUp() {};
+    void TearDown() {};
+};
+
+/**
+ * @tc.number: SUB_backup_tools_op_help_0101
+ * @tc.name: SUB_backup_tools_op_help_0101
+ * @tc.desc: ����Execute��֧
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: I6F3GV
+ */
+HWTEST_F(ToolsOpHelpTest, SUB_backup_tools_op_help_0101, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "ToolsOpHelpTest-begin SUB_backup_tools_op_help_0101";
+    try {
+        GTEST_LOG_(INFO) << "ToolsOpHelpTest-info";
+        HelpRegister();
+        map<string, vector<string>> mapArgToVal;
+        vector<string> path = {"/data/backup/tmp"};
+        mapArgToVal.insert(make_pair("pathCapFile", path));
+        vector<string> bundles = {"com.example.app2backup"};
+        mapArgToVal.insert(make_pair("bundles", bundles));
+        vector<string> local = {"false"};
+        mapArgToVal.insert(make_pair("isLocal", local));
+        vector<string_view> curOp;
+        curOp.emplace_back("help");        
+        auto tryOpSucceed = [&curOp](const ToolsOp &op) { return op.TryMatch(curOp); };
+        auto &&opeartions = ToolsOp::GetAllOperations();
+        auto matchedOp = find_if(opeartions.begin(), opeartions.end(), tryOpSucceed);
+        if (matchedOp != opeartions.end()) {
+            matchedOp->Execute(mapArgToVal);
+        }
+        curOp.clear();
+        curOp.emplace_back("backup");
+        if (matchedOp != opeartions.end()) {
+            matchedOp->Execute(mapArgToVal);
+        }
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "ToolsOpHelpTest-an exception occurred by construction.";
+    }
+    GTEST_LOG_(INFO) << "ToolsOpHelpTest-end SUB_backup_tools_op_help_0101";
+}
+
+}
\ No newline at end of file
diff --git a/tests/unittests/backup_tools/backup_tool/tools_op_restore_async_test.cpp b/tests/unittests/backup_tools/backup_tool/tools_op_restore_async_test.cpp
index a4e86e16f8e3d43663666c31e1152e517c278e9e..07177f3055aaabc447174e16bc553af0ca7193a7 100644
--- a/tests/unittests/backup_tools/backup_tool/tools_op_restore_async_test.cpp
+++ b/tests/unittests/backup_tools/backup_tool/tools_op_restore_async_test.cpp
@@ -18,7 +18,7 @@
 #include <sstream>
 
 #include <gtest/gtest.h>
-
+#include "tools_op_restore_async.h"
 #include "b_resources/b_constants.h"
 #include "tools_op.h"
 
@@ -53,6 +53,7 @@ HWTEST_F(ToolsOpRestoreAsyncTest, SUB_backup_tools_op_restore_async_0100, testin
     GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-begin SUB_backup_tools_op_restore_async_0100";
     try {
         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-info";
+        RestoreAsyncRegister();
         map<string, vector<string>> mapArgToVal;
         string localCap = string(BConstants::SA_BUNDLE_BACKUP_TMP_DIR.data()) + "/tmp";
         vector<string> path = {localCap.data()};
@@ -121,6 +122,7 @@ HWTEST_F(ToolsOpRestoreAsyncTest, SUB_backup_tools_op_restore_async_0200, testin
     try {
         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-The pathCapFile field is not contained.";
         map<string, vector<string>> mapArgToVal;
+        RestoreAsyncRegister();
         vector<string> bundles = {"com.example.app2backup"};
         vector<string> path = {"/data/backup/tmp"};
         mapArgToVal.insert(make_pair("bundles", bundles));
@@ -162,6 +164,11 @@ HWTEST_F(ToolsOpRestoreAsyncTest, SUB_backup_tools_op_restore_async_0200, testin
             mapArgToVal.clear();
             ret = matchedOp->Execute(mapArgToVal);
             EXPECT_NE(ret, 0);
+
+            vector<string> path1 = {"/tmp/abdc/efg"};
+            mapArgToVal.insert(make_pair("pathCapFile", path1));
+            ret = matchedOp->Execute(mapArgToVal);
+            EXPECT_NE(ret, 0);
         }
     } catch (...) {
         EXPECT_TRUE(false);
diff --git a/tests/unittests/backup_tools/backup_tool/tools_op_restore_test.cpp b/tests/unittests/backup_tools/backup_tool/tools_op_restore_test.cpp
index c8d9ee169f4b7cd43990d7d3bce13e3dbc9696c6..ccb5fc4357831b7375d1913ea13d5950651c5d7a 100644
--- a/tests/unittests/backup_tools/backup_tool/tools_op_restore_test.cpp
+++ b/tests/unittests/backup_tools/backup_tool/tools_op_restore_test.cpp
@@ -18,7 +18,7 @@
 #include <sstream>
 
 #include <gtest/gtest.h>
-
+#include <tools_op_restore.h>
 #include "b_resources/b_constants.h"
 #include "tools_op.h"
 
@@ -53,6 +53,7 @@ HWTEST_F(ToolsOpRestoreTest, SUB_backup_tools_op_restore_0100, testing::ext::Tes
     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-begin SUB_backup_tools_op_restore_0100";
     try {
         GTEST_LOG_(INFO) << "ToolsOpRestoreTest-info";
+        RestoreRegister();
         map<string, vector<string>> mapArgToVal;
         string localCap = string(BConstants::GetSaBundleBackupToolDir(BConstants::DEFAULT_USER_ID).data()) + "/tmp";
         vector<string> path = {localCap.data()};
@@ -104,6 +105,7 @@ HWTEST_F(ToolsOpRestoreTest, SUB_backup_tools_op_restore_0200, testing::ext::Tes
     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-begin SUB_backup_tools_op_restore_0200";
     try {
         GTEST_LOG_(INFO) << "ToolsOpRestoreTest-The pathCapFile field is not contained.";
+        RestoreRegister();
         map<string, vector<string>> mapArgToVal;
         vector<string> bundles = {"com.example.app2backup"};
         vector<string> path = {"/data/backup/tmp"};
@@ -138,4 +140,119 @@ HWTEST_F(ToolsOpRestoreTest, SUB_backup_tools_op_restore_0200, testing::ext::Tes
     }
     GTEST_LOG_(INFO) << "ToolsOpRestoreTest-end SUB_backup_tools_op_restore_0200";
 }
+
+/**
+ * @tc.number: SUB_backup_tools_op_restore_0300
+ * @tc.name: SUB_backup_tools_op_restore_0300
+ * @tc.desc: 测试
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: I6F3GV
+ */
+HWTEST_F(ToolsOpRestoreTest, SUB_backup_tools_op_restore_0300, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "ToolsOpRestoreTest-begin SUB_backup_tools_op_restore_0300";
+    try {
+        GTEST_LOG_(INFO) << "ToolsOpRestoreTest-The pathCapFile field is not contained.";
+        RestoreRegister();
+        map<string, vector<string>> mapArgToVal;
+        
+        vector<string> bundles = {"com.example.app2backup"};
+        vector<string> path = {"/data/backup/tmp"};
+        vector<string> depMode = {"true"};
+        mapArgToVal.insert(make_pair("pathCapFile", path));
+        mapArgToVal.insert(make_pair("bundles", bundles));
+        mapArgToVal.insert(make_pair("depMode", depMode));
+
+        vector<string_view> curOp;
+        curOp.emplace_back("restore");
+        auto tryOpSucceed = [&curOp](const ToolsOp &op) { return op.TryMatch(curOp); };
+        auto &&opeartions = ToolsOp::GetAllOperations();
+        auto matchedOp = find_if(opeartions.begin(), opeartions.end(), tryOpSucceed);
+        int ret = 0;
+        if (matchedOp != opeartions.end()) {
+            ret = matchedOp->Execute(mapArgToVal);
+            EXPECT_NE(ret, 0);
+        }
+        GTEST_LOG_(INFO) << "ToolsOpRestoreTest-The bundles field is not contained.";
+        mapArgToVal.clear();
+        mapArgToVal.insert(make_pair("pathCapFile", path));
+        if (matchedOp != opeartions.end()) {
+            ret = matchedOp->Execute(mapArgToVal);
+            EXPECT_NE(ret, 0);
+        }
+
+        mapArgToVal.clear();
+        if (matchedOp != opeartions.end()) {
+            ret = matchedOp->Execute(mapArgToVal);
+            EXPECT_NE(ret, 0);
+        }
+
+        vector<string> path1 = {"/data/tmp/abdc"};
+        mapArgToVal.insert(make_pair("pathCapFile", path1));
+        if (matchedOp != opeartions.end()) {
+            ret = matchedOp->Execute(mapArgToVal);
+            EXPECT_NE(ret, 0);
+        }
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "ToolsOpRestoreTest-an exception occurred by construction.";
+    }
+    GTEST_LOG_(INFO) << "ToolsOpRestoreTest-end SUB_backup_tools_op_restore_0300";
+}
+
+/**
+ * @tc.number: SUB_backup_tools_op_restore_0400
+ * @tc.name: SUB_backup_tools_op_restore_0400
+ * @tc.desc: 测试
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: I6F3GV
+ */
+HWTEST_F(ToolsOpRestoreTest, SUB_backup_tools_op_restore_0400, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "ToolsOpRestoreTest-begin SUB_backup_tools_op_restore_0400";
+    try {
+        GTEST_LOG_(INFO) << "ToolsOpRestoreTest-The pathCapFile field is not contained.";
+        RestoreRegister();
+        map<string, vector<string>> mapArgToVal;
+
+        vector<string> bundles = {"com.example.app2backup"};
+        vector<string> path = {"/data/backup/tmp"};
+        vector<string> depMode = {"false"};
+        mapArgToVal.insert(make_pair("depMode", depMode));
+        mapArgToVal.insert(make_pair("bundles", bundles));
+        
+
+        vector<string_view> curOp;
+        curOp.emplace_back("restore");
+        auto tryOpSucceed = [&curOp](const ToolsOp &op) { return op.TryMatch(curOp); };
+        auto &&opeartions = ToolsOp::GetAllOperations();
+        auto matchedOp = find_if(opeartions.begin(), opeartions.end(), tryOpSucceed);
+        int ret = 0;
+        if (matchedOp != opeartions.end()) {
+            ret = matchedOp->Execute(mapArgToVal);
+            EXPECT_NE(ret, 0);
+        }
+        GTEST_LOG_(INFO) << "ToolsOpRestoreTest-The bundles field is not contained.";
+        mapArgToVal.clear();
+        mapArgToVal.insert(make_pair("pathCapFile", path));
+        if (matchedOp != opeartions.end()) {
+            ret = matchedOp->Execute(mapArgToVal);
+            EXPECT_NE(ret, 0);
+        }
+
+        mapArgToVal.clear();
+        if (matchedOp != opeartions.end()) {
+            ret = matchedOp->Execute(mapArgToVal);
+            EXPECT_NE(ret, 0);
+        }
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "ToolsOpRestoreTest-an exception occurred by construction.";
+    }
+    GTEST_LOG_(INFO) << "ToolsOpRestoreTest-end SUB_backup_tools_op_restore_0400";
+}
 } // namespace OHOS::FileManagement::Backup
\ No newline at end of file
diff --git a/tests/unittests/backup_tools/backup_tool/tools_op_test.cpp b/tests/unittests/backup_tools/backup_tool/tools_op_test.cpp
index 526295b505905d79c53a93279dc0682e19a80fee..b27f6b31e5f694591d6e15ffd6ca52024c37825c 100644
--- a/tests/unittests/backup_tools/backup_tool/tools_op_test.cpp
+++ b/tests/unittests/backup_tools/backup_tool/tools_op_test.cpp
@@ -18,7 +18,7 @@
 #include <sstream>
 
 #include <gtest/gtest.h>
-
+#include "tools_op_backup.h"
 #include "tools_op.h"
 
 namespace OHOS::FileManagement::Backup {
@@ -93,4 +93,61 @@ HWTEST_F(ToolsOpTest, SUB_backup_tools_op_0200, testing::ext::TestSize.Level1)
     }
     GTEST_LOG_(INFO) << "ToolsOpTest-end SUB_backup_tools_op_0200";
 }
+
+/**
+ * @tc.number: SUB_backup_tools_op_0300
+ * @tc.name: SUB_backup_tools_op_0300
+ * @tc.desc: 测试GetName分支
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: I6F3GV
+ */
+HWTEST_F(ToolsOpTest, SUB_backup_tools_op_0300, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "ToolsOpTest-begin SUB_backup_tools_op_0300";
+    try {
+        GTEST_LOG_(INFO) << "ToolsOpTest-info";
+        ToolsOp obj({ToolsOp::Descriptor {
+            .opName = {"abcd", "hijk"},
+            .funcGenHelpMsg = nullptr,
+            .funcExec = nullptr,
+        }});
+        obj.GetName();
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "ToolsOpTest-an exception occurred by construction.";
+    }
+    GTEST_LOG_(INFO) << "ToolsOpTest-end SUB_backup_tools_op_0300";
+}
+
+/**
+ * @tc.number: SUB_backup_tools_op_0400
+ * @tc.name: SUB_backup_tools_op_0400
+ * @tc.desc: 测试Execute分支
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: I6F3GV
+ */
+HWTEST_F(ToolsOpTest, SUB_backup_tools_op_0400, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "ToolsOpTest-begin SUB_backup_tools_op_0400";
+    try {
+        BackUpRegister();
+        map<string, vector<string>> mapArgToVal;
+        vector<string_view> curOp;
+        curOp.emplace_back("test");
+        auto tryOpSucceed = [&curOp](const ToolsOp &op) { return op.TryMatch(curOp); };
+        auto &&opeartions = ToolsOp::GetAllOperations();
+        auto matchedOp = find_if(opeartions.begin(), opeartions.end(), tryOpSucceed);
+        if (matchedOp != opeartions.end()) {
+            matchedOp->Execute(mapArgToVal);
+        }
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "ToolsOpTest-an exception occurred by construction.";
+    }
+    GTEST_LOG_(INFO) << "ToolsOpTest-end SUB_backup_tools_op_0400";
+}
 } // namespace OHOS::FileManagement::Backup
\ No newline at end of file