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..d81861e52d33dd2a6e5f8801695fb45ac9080a61 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
@@ -13,7 +13,6 @@
  * limitations under the License.
  */
 
-#include <iostream>
 #include <map>
 #include <sstream>
 
@@ -21,6 +20,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 +46,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 +108,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 +117,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));
@@ -124,12 +125,6 @@ HWTEST_F(ToolsOpBackupTest, SUB_backup_tools_op_backup_0200, testing::ext::TestS
             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) << "ToolsOpBackupTest-an exception occurred by construction.";
@@ -140,7 +135,7 @@ HWTEST_F(ToolsOpBackupTest, SUB_backup_tools_op_backup_0200, testing::ext::TestS
 /**
  * @tc.number: SUB_backup_tools_op_backup_0300
  * @tc.name: SUB_backup_tools_op_backup_0300
- * @tc.desc: 测试Exec分支
+ * @tc.desc: 测试InitPathCapFile分支
  * @tc.size: MEDIUM
  * @tc.type: FUNC
  * @tc.level Level 1
@@ -151,6 +146,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 +172,257 @@ 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..5ad02182da73386e18f6a969c653a8859529b203 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
@@ -14,11 +14,11 @@
  */
 
 #include <gtest/gtest.h>
-#include <iostream>
 #include <map>
 #include <sstream>
 
 #include "tools_op.h"
+#include "tools_op_check_sa.h"
 #include "utils_mock_global_variable.h"
 
 namespace OHOS::FileManagement::Backup {
@@ -69,4 +69,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..210777a060f94483e8156105f4e12d69b5f6f4db
--- /dev/null
+++ b/tests/unittests/backup_tools/backup_tool/tools_op_help_test.cpp
@@ -0,0 +1,75 @@
+/*
+ * 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 <map>
+#include <sstream>
+
+#include "tools_op.h"
+#include "tools_op_help.h"
+#include <gtest/gtest.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";
+}
+
+} // namespace OHOS::FileManagement::Backup
\ 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..ddb9c1263d453bfc7386257a15900aced0a417d1 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
@@ -13,14 +13,13 @@
  * limitations under the License.
  */
 
-#include <iostream>
 #include <map>
 #include <sstream>
 
-#include <gtest/gtest.h>
-
 #include "b_resources/b_constants.h"
 #include "tools_op.h"
+#include "tools_op_restore_async.h"
+#include <gtest/gtest.h>
 
 namespace OHOS::FileManagement::Backup {
 using namespace std;
@@ -53,6 +52,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()};
@@ -77,7 +77,6 @@ HWTEST_F(ToolsOpRestoreAsyncTest, SUB_backup_tools_op_restore_async_0100, testin
         system(touchTmp.c_str());
 
         // 尝试匹配当前命令，成功后执行
-        GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-restoreAsync";
         vector<string_view> curOp;
         curOp.emplace_back("restoreAsync");
         auto tryOpSucceed = [&curOp](const ToolsOp &op) { return op.TryMatch(curOp); };
@@ -121,6 +120,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));
@@ -158,10 +158,6 @@ HWTEST_F(ToolsOpRestoreAsyncTest, SUB_backup_tools_op_restore_async_0200, testin
             mapArgToVal.insert(make_pair("restoreType", restoreType));
             ret = matchedOp->Execute(mapArgToVal);
             EXPECT_NE(ret, 0);
-
-            mapArgToVal.clear();
-            ret = matchedOp->Execute(mapArgToVal);
-            EXPECT_NE(ret, 0);
         }
     } catch (...) {
         EXPECT_TRUE(false);