diff --git a/test/fuzztest/servicereverse_fuzzer/servicereverse_fuzzer.cpp b/test/fuzztest/servicereverse_fuzzer/servicereverse_fuzzer.cpp
index f1edd63b3f0cda7d7421a43b95c2b6c61e8dfa62..dbba2c2f118e8707e31ace07ea2de2128bd0f847 100644
--- a/test/fuzztest/servicereverse_fuzzer/servicereverse_fuzzer.cpp
+++ b/test/fuzztest/servicereverse_fuzzer/servicereverse_fuzzer.cpp
@@ -29,7 +29,6 @@
 #include "service_reverse_stub.h"
 #include "service_reverse.h"
 #include "securec.h"
-#include "system_ability.h"
 
 using namespace OHOS::FileManagement::Backup;
 
diff --git a/tests/mock/utils_mock/src/b_jsonutil_mock.cpp b/tests/mock/utils_mock/src/b_jsonutil_mock.cpp
index eea1cfee0298163e3fc50b55bb9af39f5423472f..6690d359555ff424e6f211c87ab15adb86684112 100644
--- a/tests/mock/utils_mock/src/b_jsonutil_mock.cpp
+++ b/tests/mock/utils_mock/src/b_jsonutil_mock.cpp
@@ -77,4 +77,10 @@ std::string BJsonUtil::BuildInitSessionErrInfo(int32_t userId, string callerName
 {
     return BBJsonUtil::jsonUtil->BuildInitSessionErrInfo(userId, callerName, activeTime);
 }
+
+bool BJsonUtil::WriteToStr(std::vector<BundleDataSize> &bundleDataList, size_t listSize, std::string scanning,
+    std::string &jsonStr)
+{
+    return BBJsonUtil::jsonUtil->WriteToStr(bundleDataList, listSize, scanning, jsonStr);
+}
 }
\ No newline at end of file
diff --git a/tests/moduletests/backup_kit_inner/BUILD.gn b/tests/moduletests/backup_kit_inner/BUILD.gn
index c3fc260eee40865512d9d714ed0bf6303853f5fd..6508451029584478159ed2735a4c0e26d698fb5a 100644
--- a/tests/moduletests/backup_kit_inner/BUILD.gn
+++ b/tests/moduletests/backup_kit_inner/BUILD.gn
@@ -40,6 +40,7 @@ ohos_unittest("b_session_test") {
   include_dirs += backup_mock_utils_include
 
   deps = [
+    "${path_backup}/interfaces/inner_api/native/backup_kit_inner:backup_kit_inner",
     "${path_backup}/tests/utils:backup_test_utils",
     "${path_backup}/utils:backup_utils",
   ]
diff --git a/tests/moduletests/backup_kit_inner/b_session_backup_test.cpp b/tests/moduletests/backup_kit_inner/b_session_backup_test.cpp
index a4a5583f2bb17510bb8674db9bd4d711ece68967..eae6c10edad5ce233f1dd0daf88f9f22cd908cb5 100644
--- a/tests/moduletests/backup_kit_inner/b_session_backup_test.cpp
+++ b/tests/moduletests/backup_kit_inner/b_session_backup_test.cpp
@@ -423,7 +423,7 @@ HWTEST_F(BSessionBackupTest, SUB_backup_b_session_backup_1100, testing::ext::Tes
     GTEST_LOG_(INFO) << "BSessionBackupTest-begin SUB_backup_b_session_backup_1100";
     try {
         if (backupPtr_ == nullptr) {
-            GTEST_LOG_(INFO) << "SUB_backup_b_session_backup_0900 backupPtr_ == nullptr";
+            GTEST_LOG_(INFO) << "SUB_backup_b_session_backup_1100 backupPtr_ == nullptr";
             return;
         }
         GTEST_LOG_(INFO) << "GetInstance is false";
@@ -436,8 +436,43 @@ HWTEST_F(BSessionBackupTest, SUB_backup_b_session_backup_1100, testing::ext::Tes
         EXPECT_LT(err, 0);
     } catch (...) {
         EXPECT_TRUE(false);
-        GTEST_LOG_(INFO) << "BSessionBackupTest-an exception occurred by RemoveExtConn.";
+        GTEST_LOG_(INFO) << "BSessionBackupTest-an exception occurred by GetLocalCapabilities.";
     }
     GTEST_LOG_(INFO) << "BSessionBackupTest-end SUB_backup_b_session_backup_1100";
 }
+
+/**
+ * @tc.number: SUB_backup_b_session_backup_1200
+ * @tc.name: SUB_backup_b_session_backup_1200
+ * @tc.desc: 测试 GetBackupDataSize 接口
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: issuesI9KPRL
+ */
+HWTEST_F(BSessionBackupTest, SUB_backup_b_session_backup_1200, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "BSessionBackupTest-begin SUB_backup_b_session_backup_1200";
+    try {
+        if (backupPtr_ == nullptr) {
+            GTEST_LOG_(INFO) << "SUB_backup_b_session_backup_1200 backupPtr_ == nullptr";
+            return;
+        }
+        GTEST_LOG_(INFO) << "GetInstance is false";
+        bool isPreciseScan = true;
+        vector<BIncrementalData> bundleNameList;
+        SetMockGetInstance(false);
+        auto err = backupPtr_->GetBackupDataSize(isPreciseScan, bundleNameList);
+        EXPECT_EQ(err, BError(BError::Codes::SDK_BROKEN_IPC).GetCode());
+
+        GTEST_LOG_(INFO) << "GetInstance is true";
+        SetMockGetInstance(true);
+        err = backupPtr_->GetBackupDataSize(isPreciseScan, bundleNameList);
+        EXPECT_EQ(err, ERR_OK);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "BSessionBackupTest-an exception occurred by GetBackupDataSize.";
+    }
+    GTEST_LOG_(INFO) << "BSessionBackupTest-end SUB_backup_b_session_backup_1200";
+}
 } // namespace OHOS::FileManagement::Backup
\ No newline at end of file
diff --git a/tests/moduletests/backup_kit_inner/b_session_restore_test.cpp b/tests/moduletests/backup_kit_inner/b_session_restore_test.cpp
index 0c2b9b32c5e31a6e80f5d88ad39fb9ce5dd7f35a..cfac6d5a464857b7c65e9720b52b2c6d96dc2856 100644
--- a/tests/moduletests/backup_kit_inner/b_session_restore_test.cpp
+++ b/tests/moduletests/backup_kit_inner/b_session_restore_test.cpp
@@ -513,4 +513,36 @@ HWTEST_F(BSessionRestoreTest, SUB_backup_b_session_restore_1100, testing::ext::T
     }
     GTEST_LOG_(INFO) << "BSessionRestoreTest-end SUB_backup_b_session_restore_1100";
 }
+
+/**
+ * @tc.number: SUB_backup_b_session_restore_1200
+ * @tc.name: SUB_backup_b_session_restore_1200
+ * @tc.desc: 测试 GetLocalCapabilities 接口
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: issuesI9KPRL
+ */
+HWTEST_F(BSessionRestoreTest, SUB_backup_b_session_restore_1200, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "BSessionRestoreTest-begin SUB_backup_b_session_restore_1200";
+    try {
+        if (restorePtr_ == nullptr) {
+            GTEST_LOG_(INFO) << "SUB_backup_b_session_restore_1200 restorePtr_ == nullptr";
+            return;
+        }
+        GTEST_LOG_(INFO) << "GetInstance is false";
+        SetMockGetInstance(false);
+        auto err = restorePtr_->GetLocalCapabilities();
+        EXPECT_LT(err, 0);
+        GTEST_LOG_(INFO) << "GetInstance is true";
+        SetMockGetInstance(true);
+        err = restorePtr_->GetLocalCapabilities();
+        EXPECT_LT(err, 0);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "BSessionRestoreTest-an exception occurred by GetLocalCapabilities.";
+    }
+    GTEST_LOG_(INFO) << "BSessionRestoreTest-end SUB_backup_b_session_restore_1200";
+}
 } // namespace OHOS::FileManagement::Backup
\ No newline at end of file
diff --git a/tests/unittests/backup_api/backup_impl/service_proxy_test.cpp b/tests/unittests/backup_api/backup_impl/service_proxy_test.cpp
index ee2de7234d61ddaaa74f63a773928a3410c877a0..0032e8d1a038ad413d63fdc0ecb6bd1f381a96c5 100644
--- a/tests/unittests/backup_api/backup_impl/service_proxy_test.cpp
+++ b/tests/unittests/backup_api/backup_impl/service_proxy_test.cpp
@@ -1441,4 +1441,86 @@ HWTEST_F(ServiceProxyTest, SUB_Service_proxy_Cancel_0100, testing::ext::TestSize
     EXPECT_NE(ret, BError(BError::Codes::OK));
     GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_Cancel_0100";
 }
+
+/**
+ * @tc.number: SUB_Service_proxy_RefreshDataSize_0100
+ * @tc.name: SUB_Service_proxy_RefreshDataSize_0100
+ * @tc.desc: 测试 RefreshDataSize 调用成功和失败
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: I90ZV5
+ */
+HWTEST_F(ServiceProxyTest, SUB_Service_proxy_RefreshDataSize_0100, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_RefreshDataSize_0100";
+    if (proxy_ == nullptr) {
+        GTEST_LOG_(INFO) << "SUB_Service_proxy_RefreshDataSize_0100 proxy_ == nullptr";
+        return;
+    }
+    int64_t totalSize = 0;
+    EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(EPERM));
+    ErrCode ret = proxy_->RefreshDataSize(totalSize);
+    EXPECT_EQ(ret, BError(BError::Codes::SDK_INVAL_ARG));
+
+    EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR));
+    ret = proxy_->RefreshDataSize(totalSize);
+    EXPECT_EQ(ret, BError(BError::Codes::SDK_INVAL_ARG));
+    GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_RefreshDataSize_0100";
+}
+
+/**
+ * @tc.number: SUB_Service_proxy_GetLocalCapabilitiesForBundleInfos_0100
+ * @tc.name: SUB_Service_proxy_GetLocalCapabilitiesForBundleInfos_0100
+ * @tc.desc: 测试 GetLocalCapabilitiesForBundleInfos 调用成功和失败
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: I90ZV5
+ */
+HWTEST_F(ServiceProxyTest, SUB_Service_proxy_GetLocalCapabilitiesForBundleInfos_0100, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_GetLocalCapabilitiesForBundleInfos_0100";
+    if (proxy_ == nullptr) {
+        GTEST_LOG_(INFO) << "SUB_Service_proxy_GetLocalCapabilitiesForBundleInfos_0100 proxy_ == nullptr";
+        return;
+    }
+    EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
+        .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest))
+        .WillOnce(Return(EPERM));
+    ErrCode ret = proxy_->GetLocalCapabilitiesForBundleInfos();
+    EXPECT_NE(ret, BError(BError::Codes::OK));
+    ret = proxy_->GetLocalCapabilitiesForBundleInfos();
+    EXPECT_NE(ret, BError(BError::Codes::OK));
+    GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_GetLocalCapabilitiesForBundleInfos_0100";
+}
+
+/**
+ * @tc.number: SUB_Service_proxy_GetBackupDataSize_0100
+ * @tc.name: SUB_Service_proxy_GetBackupDataSize_0100
+ * @tc.desc: 测试 GetBackupDataSize 调用成功和失败
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: I90ZV5
+ */
+HWTEST_F(ServiceProxyTest, SUB_Service_proxy_GetBackupDataSize_0100, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_GetBackupDataSize_0100";
+    if (proxy_ == nullptr) {
+        GTEST_LOG_(INFO) << "SUB_Service_proxy_GetBackupDataSize_0100 proxy_ == nullptr";
+        return;
+    }
+    EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
+        .Times(2)
+        .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest))
+        .WillOnce(Return(EPERM));
+    bool isPreciseScan = true;
+    vector<BIncrementalData> bundleNameList;
+    ErrCode ret = proxy_->GetBackupDataSize(isPreciseScan, bundleNameList);
+    EXPECT_EQ(ret, BError(BError::Codes::OK));
+    ret = proxy_->GetBackupDataSize(isPreciseScan, bundleNameList);
+    EXPECT_NE(ret, BError(BError::Codes::OK));
+    GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_GetBackupDataSize_0100";
+}
 } // namespace OHOS::FileManagement::Backup
\ No newline at end of file
diff --git a/tests/unittests/backup_api/backup_impl/service_reverse_stub_test.cpp b/tests/unittests/backup_api/backup_impl/service_reverse_stub_test.cpp
index 7c2284f6bf33b9c9b602d1cda4e592fc641fb8a1..268005e538f7d0bc840e707d960fbfe37395731d 100644
--- a/tests/unittests/backup_api/backup_impl/service_reverse_stub_test.cpp
+++ b/tests/unittests/backup_api/backup_impl/service_reverse_stub_test.cpp
@@ -886,4 +886,75 @@ HWTEST_F(ServiceReverseStubTest,
     GTEST_LOG_(INFO)
         << "ServiceReverseStubTest-end SUB_backup_ServiceReverseStub_IncrementalRestoreOnResultReport_0100";
 }
+
+/**
+ * @tc.number: SUB_backup_ServiceReverseStub_BackupOnScanningInfo_0100
+ * @tc.name: SUB_backup_ServiceReverseStub_BackupOnScanningInfo_0100
+ * @tc.desc: Test function of BackupOnScanningInfo interface for SUCCESS.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: I6F3GV
+ */
+HWTEST_F(ServiceReverseStubTest,
+         SUB_backup_ServiceReverseStub_BackupOnScanningInfo_0100,
+         testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "ServiceReverseStubTest-begin SUB_backup_ServiceReverseStub_BackupOnScanningInfo_0100";
+    try {
+        MockServiceReverse service;
+        EXPECT_CALL(service, BackupOnScanningInfo(_)).WillOnce(Return());
+        MessageParcel data;
+        MessageParcel reply;
+        MessageOption option;
+
+        EXPECT_TRUE(data.WriteInterfaceToken(IServiceReverse::GetDescriptor()));
+        EXPECT_TRUE(data.WriteString(BUNDLE_NAME));
+
+        EXPECT_EQ(BError(BError::Codes::OK),
+                  service.OnRemoteRequest(
+                      static_cast<uint32_t>(IServiceReverseInterfaceCode::SERVICER_BACKUP_ON_SCANNED_INFO), data,
+                      reply, option));
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "ServiceReverseStubTest-an exception occurred by BackupOnScanningInfo.";
+    }
+    GTEST_LOG_(INFO) << "ServiceReverseStubTest-end SUB_backup_ServiceReverseStub_BackupOnScanningInfo_0100";
+}
+
+/**
+ * @tc.number: SUB_backup_ServiceReverseStub_IncrementalBackupOnScanningInfo_0100
+ * @tc.name: SUB_backup_ServiceReverseStub_IncrementalBackupOnScanningInfo_0100
+ * @tc.desc: Test function of IncrementalBackupOnScanningInfo interface for SUCCESS.
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: I6F3GV
+ */
+HWTEST_F(ServiceReverseStubTest,
+         SUB_backup_ServiceReverseStub_IncrementalBackupOnScanningInfo_0100,
+         testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) <<
+        "ServiceReverseStubTest-begin SUB_backup_ServiceReverseStub_IncrementalBackupOnScanningInfo_0100";
+    try {
+        MockServiceReverse service;
+        MessageParcel data;
+        MessageParcel reply;
+        MessageOption option;
+        EXPECT_TRUE(data.WriteInterfaceToken(IServiceReverse::GetDescriptor()));
+        EXPECT_TRUE(data.WriteString(BUNDLE_NAME));
+
+        EXPECT_CALL(service, IncrementalBackupOnScanningInfo(_)).WillOnce(Return());
+        EXPECT_EQ(BError(BError::Codes::OK),
+                  service.OnRemoteRequest(
+                      static_cast<uint32_t>(
+                        IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_BACKUP_ON_SCANNED_INFO),
+                        data, reply, option));
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "ServiceReverseStubTest-an exception occurred by BackupOnScanningInfo.";
+    }
+    GTEST_LOG_(INFO) << "ServiceReverseStubTest-end SUB_backup_ServiceReverseStub_IncrementalBackupOnScanningInfo_0100";
+}
 } // namespace OHOS::FileManagement::Backup
\ No newline at end of file
diff --git a/tests/unittests/backup_api/backup_impl/service_reverse_test.cpp b/tests/unittests/backup_api/backup_impl/service_reverse_test.cpp
index 98bccfac2d5691c8908071cec4c743556ec0cf1a..1f5cb90e6929ad24009cf74e2da5f9b975478333 100644
--- a/tests/unittests/backup_api/backup_impl/service_reverse_test.cpp
+++ b/tests/unittests/backup_api/backup_impl/service_reverse_test.cpp
@@ -1751,4 +1751,118 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_IncrementalBackupOnResult
     }
     GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalBackupOnResultReport_0101";
 }
+
+/**
+ * @tc.number: SUB_backup_ServiceReverse_BackupOnScanningInfo_0100
+ * @tc.name: SUB_backup_ServiceReverse_BackupOnScanningInfo_0100
+ * @tc.desc: 测试 BackupOnScanningInfo 接口
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: I6F3GV
+ */
+HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnScanningInfo_0100, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnScanningInfo_0100";
+    try {
+        Init(IServiceReverse::Scenario::BACKUP);
+        if (service_ == nullptr) {
+            GTEST_LOG_(INFO) <<
+                "SUB_backup_ServiceReverse_BackupOnScanningInfo_0100 service_ == nullptr";
+            return;
+        }
+        std::string scannedInfo = "";
+        service_->BackupOnScanningInfo(scannedInfo);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by BackupOnScanningInfo.";
+    }
+    GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_BackupOnScanningInfo_0100";
+}
+
+/**
+ * @tc.number: SUB_backup_ServiceReverse_BackupOnScanningInfo_0101
+ * @tc.name: SUB_backup_ServiceReverse_BackupOnScanningInfo_0101
+ * @tc.desc: 测试 BackupOnScanningInfo 接口
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: I6F3GV
+ */
+HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnScanningInfo_0101, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnScanningInfo_0101";
+    try {
+        Init(IServiceReverse::Scenario::RESTORE);
+        if (service_ == nullptr) {
+            GTEST_LOG_(INFO) <<
+                "SUB_backup_ServiceReverse_BackupOnScanningInfo_0101 service_ == nullptr";
+            return;
+        }
+        std::string scannedInfo = "";
+        service_->BackupOnScanningInfo(scannedInfo);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by BackupOnScanningInfo.";
+    }
+    GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_BackupOnScanningInfo_0101";
+}
+
+/**
+ * @tc.number: SUB_backup_ServiceReverse_IncrementalBackupOnScanningInfo_0100
+ * @tc.name: SUB_backup_ServiceReverse_IncrementalBackupOnScanningInfo_0100
+ * @tc.desc: 测试 IncrementalBackupOnScanningInfo 接口
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: I6F3GV
+ */
+HWTEST_F(ServiceReverseTest,
+    SUB_backup_ServiceReverse_IncrementalBackupOnScanningInfo_0100, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalBackupOnScanningInfo_0100";
+    try {
+        Init(IServiceReverse::Scenario::RESTORE);
+        if (service_ == nullptr) {
+            GTEST_LOG_(INFO) <<
+                "SUB_backup_ServiceReverse_IncrementalBackupOnScanningInfo_0100 service_ == nullptr";
+            return;
+        }
+        std::string scannedInfo = "";
+        service_->BackupOnScanningInfo(scannedInfo);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by BackupOnScanningInfo.";
+    }
+    GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalBackupOnScanningInfo_0100";
+}
+
+/**
+ * @tc.number: SUB_backup_ServiceReverse_IncrementalBackupOnScanningInfo_0101
+ * @tc.name: SUB_backup_ServiceReverse_IncrementalBackupOnScanningInfo_0101
+ * @tc.desc: 测试 IncrementalBackupOnScanningInfo 接口
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: I6F3GV
+ */
+HWTEST_F(ServiceReverseTest,
+    SUB_backup_ServiceReverse_IncrementalBackupOnScanningInfo_0101, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalBackupOnScanningInfo_0101";
+    try {
+        Init(IServiceReverse::Scenario::BACKUP);
+        if (service_ == nullptr) {
+            GTEST_LOG_(INFO) <<
+                "SUB_backup_ServiceReverse_IncrementalBackupOnScanningInfo_0101 service_ == nullptr";
+            return;
+        }
+        std::string scannedInfo = "";
+        service_->BackupOnScanningInfo(scannedInfo);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by BackupOnScanningInfo.";
+    }
+    GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalBackupOnScanningInfo_0101";
+}
 } // namespace OHOS::FileManagement::Backup
\ No newline at end of file
diff --git a/tests/unittests/backup_ext/ext_backup_js_test.cpp b/tests/unittests/backup_ext/ext_backup_js_test.cpp
index 9d3757cd444fda9edf8464d2314fd6fb4aff16d4..a404b0cc1b1e1154b6e07a0ef4bb89fc8edbee00 100644
--- a/tests/unittests/backup_ext/ext_backup_js_test.cpp
+++ b/tests/unittests/backup_ext/ext_backup_js_test.cpp
@@ -1019,11 +1019,14 @@ HWTEST_F(ExtBackupJsTest, SUB_backup_ext_js_DoCallJsMethod_0100, testing::ext::T
 {
     GTEST_LOG_(INFO) << "ExtBackupJsTest-begin SUB_backup_ext_js_DoCallJsMethod_0100";
     try {
+        auto ret = DoCallJsMethod(nullptr);
+        EXPECT_EQ(ret, EINVAL);
+
         string funcName = "";
         InputArgsParser argParserIn = {};
         ResultValueParser retParserIn = {};
         auto param = make_shared<CallJsParam>(funcName, nullptr, nullptr, argParserIn, retParserIn);
-        auto ret = DoCallJsMethod(param.get());
+        ret = DoCallJsMethod(param.get());
         EXPECT_EQ(ret, EINVAL);
 
         param->jsRuntime = jsRuntime.get();
@@ -1183,39 +1186,14 @@ HWTEST_F(ExtBackupJsTest, SUB_backup_ext_js_InvokeAppExtMethod_0100, testing::ex
         result = "test";
         ret = extBackupJs->InvokeAppExtMethod(errCode, result);
         EXPECT_EQ(ret, ERR_OK);
-    } catch (...) {
-        EXPECT_TRUE(false);
-        GTEST_LOG_(INFO) << "ExtBackupJsTest-an exception occurred by InvokeAppExtMethod.";
-    }
-    GTEST_LOG_(INFO) << "ExtBackupJsTest-end SUB_backup_ext_js_InvokeAppExtMethod_0100";
-}
-
-/**
- * @tc.number: SUB_backup_ext_js_InvokeAppExtMethod_0200
- * @tc.name: SUB_backup_ext_js_InvokeAppExtMethod_0200
- * @tc.desc: 测试 InvokeAppExtMethod 各个分支成功与失败
- * @tc.size: MEDIUM
- * @tc.type: FUNC
- * @tc.level Level 1
- * @tc.require: issuesIAFBOS
- */
-HWTEST_F(ExtBackupJsTest, SUB_backup_ext_js_InvokeAppExtMethod_0200, testing::ext::TestSize.Level1)
-{
-    GTEST_LOG_(INFO) << "ExtBackupJsTest-begin SUB_backup_ext_js_InvokeAppExtMethod_0200";
-    try {
-        ErrCode errCode = BError(BError::Codes::EXT_INVAL_ARG);
-        string result = "";
-        auto ret = extBackupJs->InvokeAppExtMethod(errCode, result);
-        EXPECT_EQ(ret, ERR_OK);
 
-        result = "test";
-        ret = extBackupJs->InvokeAppExtMethod(errCode, result);
+        ret = extBackupJs->InvokeAppExtMethod(BError(BError::Codes::EXT_INVAL_ARG), result);
         EXPECT_EQ(ret, ERR_OK);
     } catch (...) {
         EXPECT_TRUE(false);
         GTEST_LOG_(INFO) << "ExtBackupJsTest-an exception occurred by InvokeAppExtMethod.";
     }
-    GTEST_LOG_(INFO) << "ExtBackupJsTest-end SUB_backup_ext_js_InvokeAppExtMethod_0200";
+    GTEST_LOG_(INFO) << "ExtBackupJsTest-end SUB_backup_ext_js_InvokeAppExtMethod_0100";
 }
 
 /**
diff --git a/tests/unittests/backup_sa/module_external/BUILD.gn b/tests/unittests/backup_sa/module_external/BUILD.gn
index 641af865090c18ba2be1564540a9e263f57a830e..7c1fd75907b0e1aee155619ef7f249e959bef009 100644
--- a/tests/unittests/backup_sa/module_external/BUILD.gn
+++ b/tests/unittests/backup_sa/module_external/BUILD.gn
@@ -25,9 +25,16 @@ ohos_unittest("bms_adapter_test") {
     "${path_backup_mock}/utils_mock/include",
   ]
 
-  sources = [ "bms_adapter_test.cpp" ]
+  sources = [
+    "${path_backup_mock}/utils_mock/src/b_jsonutil_mock.cpp",
+    "${path_backup_mock}/utils_mock/src/b_sa_utils_mock.cpp",
+    "bms_adapter_test.cpp",
+  ]
 
-  deps = [ "${path_backup}/services/backup_sa:backup_sa" ]
+  deps = [
+    "${path_backup}/interfaces/inner_api/native/backup_kit_inner:backup_kit_inner",
+    "${path_backup}/services/backup_sa:backup_sa",
+  ]
 
   defines = [
     "LOG_TAG=\"app_file_service\"",
diff --git a/tests/unittests/backup_sa/module_external/bms_adapter_test.cpp b/tests/unittests/backup_sa/module_external/bms_adapter_test.cpp
index a85fcee277638ee681e1000c7ed6302358ea3ace..bcdec2d3587082eb60287aa06cce35536af4ff3d 100644
--- a/tests/unittests/backup_sa/module_external/bms_adapter_test.cpp
+++ b/tests/unittests/backup_sa/module_external/bms_adapter_test.cpp
@@ -17,6 +17,7 @@
 
 #include <vector>
 
+#include "b_jsonutil_mock.h"
 #include "b_sa_utils_mock.h"
 #include "if_system_ability_manager.h"
 #include "iremote_stub.h"
@@ -88,6 +89,7 @@ public:
     static inline sptr<BundleMgrMock> bms = nullptr;
     static inline sptr<SystemAbilityManagerMock> sam = nullptr;
     static inline shared_ptr<SAUtilsMock> saUtils = nullptr;
+    static inline shared_ptr<BJsonUtilMock> jsonUtil = nullptr;
 };
 
 void BmsAdapterTest::SetUpTestCase()
@@ -96,6 +98,8 @@ void BmsAdapterTest::SetUpTestCase()
     bms = sptr<BundleMgrMock>(new BundleMgrMock());
     saUtils = make_shared<SAUtilsMock>();
     SAUtilsMock::utils = saUtils;
+    jsonUtil = make_shared<BJsonUtilMock>();
+    BJsonUtilMock::jsonUtil = jsonUtil;
 }
 
 void BmsAdapterTest::TearDownTestCase()
@@ -104,6 +108,8 @@ void BmsAdapterTest::TearDownTestCase()
     sam = nullptr;
     SAUtilsMock::utils = nullptr;
     saUtils = nullptr;
+    BJsonUtilMock::jsonUtil = nullptr;
+    jsonUtil = nullptr;
 }
 
 sptr<ISystemAbilityManager> SystemAbilityManagerClient::GetSystemAbilityManager()
@@ -208,12 +214,30 @@ HWTEST_F(BmsAdapterTest, SUB_bms_adapter_CreatBackupEnv_test_0000, testing::ext:
     GTEST_LOG_(INFO) << "BmsAdapterTest-begin SUB_bms_adapter_CreatBackupEnv_test_0000";
     try {
         std::vector<BIncrementalData> bundleNameList;
-        EXPECT_CALL(*sam, GetSystemAbility(_)).WillOnce(Return(bms)).WillOnce(Return(bms));
+        BIncrementalData data;
+        data.bundleName = BUNDLE_NAME;
+        data.lastIncrementalTime = 0;
+        bundleNameList.push_back(data);
+        EXPECT_CALL(*sam, GetSystemAbility(_)).WillOnce(Return(bms));
         EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(true));
         BundleMgrAdapter::CreatBackupEnv(bundleNameList, USER_ID);
         EXPECT_TRUE(true);
 
+        BJsonUtil::BundleDetailInfo info;
+        EXPECT_CALL(*sam, GetSystemAbility(_)).WillOnce(Return(bms));
+        EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(false));
+        EXPECT_CALL(*jsonUtil, ParseBundleNameIndexStr(_)).WillOnce(Return(info));
+        EXPECT_CALL(*bms, GetCloneBundleInfo(_, _, _, _, _)).WillOnce(Return(1));
+        BundleMgrAdapter::CreatBackupEnv(bundleNameList, USER_ID);
+        EXPECT_TRUE(true);
+
+        AppExecFwk::BundleInfo bundleInfo;
+        bundleInfo.applicationInfo.codePath = "5";
+        EXPECT_CALL(*sam, GetSystemAbility(_)).WillOnce(Return(bms));
         EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(false));
+        EXPECT_CALL(*jsonUtil, ParseBundleNameIndexStr(_)).WillOnce(Return(info));
+        EXPECT_CALL(*bms, GetCloneBundleInfo(_, _, _, _, _))
+            .WillOnce(DoAll(SetArgReferee<3>(bundleInfo), Return(ERR_OK)));
         BundleMgrAdapter::CreatBackupEnv(bundleNameList, USER_ID);
         EXPECT_TRUE(true);
     } catch (...) {
diff --git a/tests/unittests/backup_sa/module_ipc/sub_service_test.cpp b/tests/unittests/backup_sa/module_ipc/sub_service_test.cpp
index a982e92e2f4e05961e6401364e4dbffd6e1951af..fd9a45968f006c06b722ff9853b0cd3c664ea6af 100644
--- a/tests/unittests/backup_sa/module_ipc/sub_service_test.cpp
+++ b/tests/unittests/backup_sa/module_ipc/sub_service_test.cpp
@@ -1515,17 +1515,17 @@ HWTEST_F(ServiceTest, SUB_Service_TimeoutRadarReport_0000, TestSize.Level1)
 }
 
 /**
- * @tc.number: SUB_Service_GetLocalCapabilitiesForBdInfos_0000
- * @tc.name: SUB_Service_GetLocalCapabilitiesForBdInfos_0000
+ * @tc.number: SUB_Service_GetLocalCapabilitiesForBundleInfos_0000
+ * @tc.name: SUB_Service_GetLocalCapabilitiesForBundleInfos_0000
  * @tc.desc: 测试 GetLocalCapabilitiesForBundleInfos 的正常/异常分支
  * @tc.size: MEDIUM
  * @tc.type: FUNC
  * @tc.level Level 1
  * @tc.require: issueIAKC3I
  */
-HWTEST_F(ServiceTest, SUB_Service_GetLocalCapabilitiesForBdInfos_0000, TestSize.Level1)
+HWTEST_F(ServiceTest, SUB_Service_GetLocalCapabilitiesForBundleInfos_0000, TestSize.Level1)
 {
-    GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_GetLocalCapabilitiesForBdInfos_0000";
+    GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_GetLocalCapabilitiesForBundleInfos_0000";
     try {
         ASSERT_TRUE(service != nullptr);
         auto session_  = service->session_;
@@ -1543,7 +1543,7 @@ HWTEST_F(ServiceTest, SUB_Service_GetLocalCapabilitiesForBdInfos_0000, TestSize.
         EXPECT_TRUE(false);
         GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by GetLocalCapabilitiesForBundleInfos.";
     }
-    GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_GetLocalCapabilitiesForBdInfos_0000";
+    GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_GetLocalCapabilitiesForBundleInfos_0000";
 }
 
 /**
@@ -1611,8 +1611,13 @@ HWTEST_F(ServiceTest, SUB_Service_GetScanningInfo_0000, TestSize.Level1)
     try {
         size_t size = 1;
         string scanning = BUNDLE_NAME;
-        bool ret = service->GetScanningInfo(nullptr, size, scanning);
-        EXPECT_FALSE(ret);
+        EXPECT_FALSE(service->GetScanningInfo(nullptr, size, scanning));
+
+        EXPECT_CALL(*jsonUtil, WriteToStr(_, _, _, _)).WillOnce(Return(false));
+        EXPECT_FALSE(service->GetScanningInfo(service, size, scanning));
+
+        EXPECT_CALL(*jsonUtil, WriteToStr(_, _, _, _)).WillOnce(Return(true));
+        EXPECT_TRUE(service->GetScanningInfo(service, size, scanning));
     } catch (...) {
         EXPECT_TRUE(false);
         GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by GetScanningInfo.";
@@ -1899,7 +1904,7 @@ HWTEST_F(ServiceTest, SUB_Service_GetDataSizeStepByStep_0000, TestSize.Level1)
         EXPECT_TRUE(true);
 
         isPreciseScan = true;
-                EXPECT_CALL(*task, AddTask(_)).WillOnce(WithArgs<0>(Invoke([](const ThreadPool::Task &f) {
+        EXPECT_CALL(*task, AddTask(_)).WillOnce(WithArgs<0>(Invoke([](const ThreadPool::Task &f) {
             f();
         })));
         service->GetDataSizeStepByStep(isPreciseScan, bundleNameList, scanning);
@@ -1909,4 +1914,75 @@ HWTEST_F(ServiceTest, SUB_Service_GetDataSizeStepByStep_0000, TestSize.Level1)
         GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by GetDataSizeStepByStep.";
     }
     GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_GetDataSizeStepByStep_0000";
+}
+
+/**
+ * @tc.number: SUB_Service_CyclicSendScannedInfo_0000
+ * @tc.name: SUB_Service_CyclicSendScannedInfo_0000
+ * @tc.desc: 测试 CyclicSendScannedInfo 接口
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: issueIAKC3I
+ */
+HWTEST_F(ServiceTest, SUB_Service_CyclicSendScannedInfo_0000, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_CyclicSendScannedInfo_0000";
+    try {
+        bool isPreciseScan = false;
+        vector<BIncrementalData> bundleNameList;
+        EXPECT_CALL(*task, AddTask(_)).WillOnce(WithArgs<0>(Invoke([](const ThreadPool::Task &f) {
+            f();
+        }))).WillOnce(WithArgs<0>(Invoke([](const ThreadPool::Task &f) {
+            service->isScannedEnd_.store(true);
+        })));
+        service->CyclicSendScannedInfo(isPreciseScan, bundleNameList);
+        EXPECT_TRUE(true);
+
+        isPreciseScan = true;
+        EXPECT_CALL(*task, AddTask(_)).WillOnce(WithArgs<0>(Invoke([](const ThreadPool::Task &f) {
+            f();
+        }))).WillOnce(WithArgs<0>(Invoke([](const ThreadPool::Task &f) {
+            service->isScannedEnd_.store(true);
+        })));
+        service->CyclicSendScannedInfo(isPreciseScan, bundleNameList);
+        EXPECT_TRUE(true);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by CyclicSendScannedInfo.";
+    }
+    GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_CyclicSendScannedInfo_0000";
+}
+
+/**
+ * @tc.number: SUB_Service_SendScannedInfo_0000
+ * @tc.name: SUB_Service_SendScannedInfo_0000
+ * @tc.desc: 测试 SendScannedInfo 接口
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: issueIAKC3I
+ */
+HWTEST_F(ServiceTest, SUB_Service_SendScannedInfo_0000, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_SendScannedInfo_0000";
+    try {
+        string scannendInfos = "";
+        service->SendScannedInfo(scannendInfos, nullptr);
+        EXPECT_TRUE(true);
+
+        auto session_ = service->session_;
+        EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED));
+        EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
+        EXPECT_CALL(*srProxy, BackupOnScanningInfo(_)).WillOnce(Return());
+        EXPECT_CALL(*task, AddTask(_)).WillOnce(WithArgs<0>(Invoke([](const ThreadPool::Task &f) {
+            f();
+        })));
+        service->SendScannedInfo(scannendInfos, session_);
+        EXPECT_TRUE(true);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by CyclicSendScannedInfo.";
+    }
+    GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_SendScannedInfo_0000";
 }
\ No newline at end of file
diff --git a/tests/unittests/backup_sa/session/b_incremental_session_test.cpp b/tests/unittests/backup_sa/session/b_incremental_session_test.cpp
index e074a00e097a24620512974e8358bc27aa184d4a..3eda5df611a373c827691d2944146611bb1f5994 100644
--- a/tests/unittests/backup_sa/session/b_incremental_session_test.cpp
+++ b/tests/unittests/backup_sa/session/b_incremental_session_test.cpp
@@ -897,4 +897,39 @@ HWTEST_F(IncrementalSessionTest, SUB_b_incremental_session_test_2700, testing::e
     }
     GTEST_LOG_(INFO) << "IncrementalSessionTest-end SUB_b_incremental_session_test_2700";
 }
+
+/**
+ * @tc.number: SUB_b_incremental_session_test_2800
+ * @tc.name: SUB_b_incremental_session_test_2800
+ * @tc.desc: 测试 GetBackupDataSize 接口
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: issuesI9KPRL
+ */
+HWTEST_F(IncrementalSessionTest, SUB_b_incremental_session_test_2800, testing::ext::TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "IncrementalSessionTest-begin SUB_b_incremental_session_test_2800";
+    try {
+        bool isPreciseScan = false;
+        vector<BIncrementalData> bundleNameList;
+        ServiceProxy::serviceProxy_ = nullptr;
+        ASSERT_TRUE(backupSession != nullptr);
+        auto err = backupSession->GetBackupDataSize(isPreciseScan, bundleNameList);
+        EXPECT_EQ(err, BError(BError::Codes::SDK_BROKEN_IPC).GetCode());
+
+        ServiceProxy::serviceProxy_ = proxy;
+        EXPECT_CALL(*proxy, GetBackupDataSize(_, _)).WillOnce(Return(BError(BError::Codes::SDK_BROKEN_IPC).GetCode()));
+        err = backupSession->GetBackupDataSize(isPreciseScan, bundleNameList);
+        EXPECT_EQ(err, BError(BError::Codes::SDK_BROKEN_IPC).GetCode());
+
+        EXPECT_CALL(*proxy, GetBackupDataSize(_, _)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
+        err = backupSession->GetBackupDataSize(isPreciseScan, bundleNameList);
+        EXPECT_EQ(err, ERR_OK);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "IncrementalSessionTest-an exception occurred by GetBackupDataSize.";
+    }
+    GTEST_LOG_(INFO) << "IncrementalSessionTest-end SUB_b_incremental_session_test_2800";
+}
 } // namespace OHOS::FileManagement::Backup
\ No newline at end of file