diff --git a/tests/unittests/backup_sa/module_external/BUILD.gn b/tests/unittests/backup_sa/module_external/BUILD.gn
index d8616765e480a9d488f725380c574e0038278a94..641af865090c18ba2be1564540a9e263f57a830e 100644
--- a/tests/unittests/backup_sa/module_external/BUILD.gn
+++ b/tests/unittests/backup_sa/module_external/BUILD.gn
@@ -22,6 +22,7 @@ ohos_unittest("bms_adapter_test") {
     "${path_backup}/services/backup_sa/include",
     "${path_backup}/utils/include",
     "${path_backup}/utils/include/b_hilog",
+    "${path_backup_mock}/utils_mock/include",
   ]
 
   sources = [ "bms_adapter_test.cpp" ]
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 c96bb0b127a39e9aa548d410f74be190330ea341..4ad91d23edd841229f9b1fad502af0e14abc0693 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_sa_utils_mock.h"
 #include "if_system_ability_manager.h"
 #include "iremote_stub.h"
 #include "iservice_registry.h"
@@ -29,6 +30,8 @@ using namespace FileManagement::Backup;
 
 const string HMOS_HAP_CODE_PATH = "1";
 const string LINUX_HAP_CODE_PATH = "2";
+const string BUNDLE_NAME = "com.example.app2backup";
+const int32_t USER_ID = 100;
 
 class SystemAbilityManagerMock : public ISystemAbilityManager {
 public:
@@ -83,18 +86,23 @@ public:
 public:
     static inline sptr<BundleMgrMock> bms = nullptr;
     static inline sptr<SystemAbilityManagerMock> sam = nullptr;
+    static inline shared_ptr<SAUtilsMock> saUtils = nullptr;
 };
 
 void BmsAdapterTest::SetUpTestCase()
 {
     sam = sptr<SystemAbilityManagerMock>(new SystemAbilityManagerMock());
     bms = sptr<BundleMgrMock>(new BundleMgrMock());
+    saUtils = make_shared<SAUtilsMock>();
+    SAUtilsMock::utils = saUtils;
 }
 
 void BmsAdapterTest::TearDownTestCase()
 {
     bms = nullptr;
     sam = nullptr;
+    SAUtilsMock::utils = nullptr;
+    saUtils = nullptr;
 }
 
 sptr<ISystemAbilityManager> SystemAbilityManagerClient::GetSystemAbilityManager()
@@ -184,4 +192,33 @@ HWTEST_F(BmsAdapterTest, SUB_bms_adapter_GetBundleInfosForIndex_test_0100, testi
     }
     GTEST_LOG_(INFO) << "BmsAdapterTest-end SUB_bms_adapter_GetBundleInfosForIndex_test_0100";
 }
+
+/**
+ * @tc.number: SUB_bms_adapter_CreatBackupEnv_test_0000
+ * @tc.name: SUB_bms_adapter_CreatBackupEnv_test_0000
+ * @tc.desc: 测试 CreatBackupEnv 接口
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: issuesI9KPRL
+ */
+HWTEST_F(BmsAdapterTest, SUB_bms_adapter_CreatBackupEnv_test_0000, testing::ext::TestSize.Level1)
+{
+    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));
+        EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(true));
+        BundleMgrAdapter::CreatBackupEnv(bundleNameList, USER_ID);
+        EXPECT_TRUE(true);
+
+        EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(false));
+        BundleMgrAdapter::CreatBackupEnv(bundleNameList, USER_ID);
+        EXPECT_TRUE(true);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "BmsAdapterTest-an exception occurred by CreatBackupEnv.";
+    }
+    GTEST_LOG_(INFO) << "BmsAdapterTest-end SUB_bms_adapter_CreatBackupEnv_test_0000";
+}
 } // namespace OHOS
\ No newline at end of file
diff --git a/tests/unittests/backup_sa/module_ipc/service_other_test.cpp b/tests/unittests/backup_sa/module_ipc/service_other_test.cpp
index a34585797296e9e5e51e4955014520b6ab06909e..5df07ad2bfa747b504ab5f40d957f4d15e37466a 100644
--- a/tests/unittests/backup_sa/module_ipc/service_other_test.cpp
+++ b/tests/unittests/backup_sa/module_ipc/service_other_test.cpp
@@ -29,6 +29,7 @@
 #include "notify_work_service_mock.h"
 #include "sa_backup_connection_mock.h"
 #include "service_reverse_proxy_mock.h"
+#include "sms_adapter_mock.h"
 #include "svc_backup_connection_mock.h"
 #include "svc_extension_proxy_mock.h"
 #include "svc_restore_deps_manager_mock.h"
@@ -135,6 +136,26 @@ void Service::RemoveExtensionMutex(const BundleName&) {}
 void Service::CreateDirIfNotExist(const std::string&) {}
 }
 
+class BThreadPool {
+public:
+    virtual void AddTask(const OHOS::ThreadPool::Task&) = 0;
+public:
+    BThreadPool() = default;
+    virtual ~BThreadPool() = default;
+public:
+    static inline std::shared_ptr<BThreadPool> task = nullptr;
+};
+
+class ThreadPoolMock : public BThreadPool {
+public:
+    MOCK_METHOD(void, AddTask, (const OHOS::ThreadPool::Task&));
+};
+
+void OHOS::ThreadPool::AddTask(const OHOS::ThreadPool::Task &f)
+{
+    BThreadPool::task->AddTask(f);
+}
+
 namespace OHOS::FileManagement::Backup {
 using namespace std;
 using namespace testing;
@@ -168,6 +189,8 @@ public:
     static inline shared_ptr<SvcRestoreDepsManagerMock> depManager = nullptr;
     static inline shared_ptr<NotifyWorkServiceMock> notify = nullptr;
     static inline shared_ptr<AppGalleryDisposeProxyMock> gallery = nullptr;
+    static inline shared_ptr<StorageMgrAdapterMock> sms = nullptr;
+    static inline shared_ptr<ThreadPoolMock> task = nullptr;
 };
 
 void ServiceTest::SetUpTestCase(void)
@@ -206,6 +229,10 @@ void ServiceTest::SetUpTestCase(void)
     NotifyWorkServiceMock::notify = notify;
     gallery = make_shared<AppGalleryDisposeProxyMock>();
     AppGalleryDisposeProxyMock::proxy = gallery;
+    sms = make_shared<StorageMgrAdapterMock>();
+    StorageMgrAdapterMock::sms = sms;
+    task = make_shared<ThreadPoolMock>();
+    ThreadPoolMock::task = task;
 }
 
 void ServiceTest::TearDownTestCase()
@@ -244,6 +271,10 @@ void ServiceTest::TearDownTestCase()
     notify = nullptr;
     AppGalleryDisposeProxyMock::proxy = nullptr;
     gallery = nullptr;
+    StorageMgrAdapterMock::sms = nullptr;
+    sms = nullptr;
+    ThreadPoolMock::task = nullptr;
+    task = nullptr;
 }
 
 #include "sub_service_test.cpp"
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 1363c4a4e22ff1b8a3229ae4aa2d393379553c1b..a982e92e2f4e05961e6401364e4dbffd6e1951af 100644
--- a/tests/unittests/backup_sa/module_ipc/sub_service_test.cpp
+++ b/tests/unittests/backup_sa/module_ipc/sub_service_test.cpp
@@ -1544,4 +1544,369 @@ HWTEST_F(ServiceTest, SUB_Service_GetLocalCapabilitiesForBdInfos_0000, TestSize.
         GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by GetLocalCapabilitiesForBundleInfos.";
     }
     GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_GetLocalCapabilitiesForBdInfos_0000";
+}
+
+/**
+ * @tc.number: SUB_Service_GetBackupDataSize_0000
+ * @tc.name: SUB_Service_GetBackupDataSize_0000
+ * @tc.desc: 测试 GetBackupDataSize 接口
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: issueIAKC3I
+ */
+HWTEST_F(ServiceTest, SUB_Service_GetBackupDataSize_0000, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_GetBackupDataSize_0000";
+    try {
+        bool isPreciseScan = true;
+        vector<BIncrementalData> bundleNameList;
+        BIncrementalData data;
+        data.bundleName = BUNDLE_NAME;
+        data.lastIncrementalTime = 0;
+        bundleNameList.push_back(data);
+        auto session_ = service->session_;
+        service->session_ = nullptr;
+        auto ret = service->GetBackupDataSize(isPreciseScan, bundleNameList);
+        EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
+
+        service->session_ = session_;
+        EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0));
+        EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_NATIVE));
+        EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::SYSTEM_UID));
+        EXPECT_CALL(*token, VerifyAccessToken(_, _))
+            .WillOnce(Return(Security::AccessToken::PermissionState::PERMISSION_DENIED));
+        EXPECT_CALL(*param, GetBackupDebugOverrideAccount())
+            .WillOnce(Return(make_pair<bool, int32_t>(true, DEBUG_ID + 1)));
+        ret = service->GetBackupDataSize(isPreciseScan, bundleNameList);
+        EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
+
+        EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0));
+        EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_HAP));
+        EXPECT_CALL(*token, GetHapTokenInfo(_, _)).WillOnce(Return(0));
+        EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::SYSTEM_UID));
+        EXPECT_CALL(*param, GetBackupDebugOverrideAccount())
+            .WillOnce(Return(make_pair<bool, int32_t>(true, DEBUG_ID + 1)));
+        ret = service->GetBackupDataSize(isPreciseScan, bundleNameList);
+        EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by GetBackupDataSize.";
+    }
+    GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_GetBackupDataSize_0000";
+}
+
+/**
+ * @tc.number: SUB_Service_GetScanningInfo_0000
+ * @tc.name: SUB_Service_GetScanningInfo_0000
+ * @tc.desc: 测试 GetScanningInfo 接口
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: issueIAKC3I
+ */
+HWTEST_F(ServiceTest, SUB_Service_GetScanningInfo_0000, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_GetScanningInfo_0000";
+    try {
+        size_t size = 1;
+        string scanning = BUNDLE_NAME;
+        bool ret = service->GetScanningInfo(nullptr, size, scanning);
+        EXPECT_FALSE(ret);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by GetScanningInfo.";
+    }
+    GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_GetScanningInfo_0000";
+}
+
+/**
+ * @tc.number: SUB_Service_WriteToList_0000
+ * @tc.name: SUB_Service_WriteToList_0000
+ * @tc.desc: 测试 WriteToList 接口
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: issueIAKC3I
+ */
+HWTEST_F(ServiceTest, SUB_Service_WriteToList_0000, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_WriteToList_0000";
+    try {
+        ASSERT_TRUE(service != nullptr);
+        BJsonUtil::BundleDataSize bundleDataSize;
+        bundleDataSize.bundleName = BUNDLE_NAME;
+        bundleDataSize.dataSize = 1;
+        bundleDataSize.incDataSize = 1;
+        service->WriteToList(bundleDataSize);
+        ASSERT_TRUE(service->bundleDataSizeList_.back().bundleName == bundleDataSize.bundleName);
+        service->bundleDataSizeList_.clear();
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by WriteToList.";
+    }
+    GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_WriteToList_0000";
+}
+
+/**
+ * @tc.number: SUB_Service_DeleteFromList_0000
+ * @tc.name: SUB_Service_DeleteFromList_0000
+ * @tc.desc: 测试 DeleteFromList 接口
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: issueIAKC3I
+ */
+HWTEST_F(ServiceTest, SUB_Service_DeleteFromList_0000, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_DeleteFromList_0000";
+    try {
+        ASSERT_TRUE(service != nullptr);
+        auto ret = service->bundleDataSizeList_.size();
+        BJsonUtil::BundleDataSize bundleDataSize;
+        bundleDataSize.bundleName = BUNDLE_NAME;
+        bundleDataSize.dataSize = 1;
+        bundleDataSize.incDataSize = 1;
+        service->bundleDataSizeList_.push_back(bundleDataSize);
+        service->DeleteFromList(1);
+        EXPECT_EQ(service->bundleDataSizeList_.size(), ret);
+        service->bundleDataSizeList_.clear();
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by DeleteFromList.";
+    }
+    GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_DeleteFromList_0000";
+}
+
+/**
+ * @tc.number: SUB_Service_SetScanningInfo_0000
+ * @tc.name: SUB_Service_SetScanningInfo_0000
+ * @tc.desc: 测试 SetScanningInfo 接口
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: issueIAKC3I
+ */
+HWTEST_F(ServiceTest, SUB_Service_SetScanningInfo_0000, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_SetScanningInfo_0000";
+    try {
+        ASSERT_TRUE(service != nullptr);
+        string scanning = "";
+        string name = BUNDLE_NAME;
+        service->SetScanningInfo(scanning, name);
+        EXPECT_EQ(scanning, name);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by SetScanningInfo.";
+    }
+    GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_SetScanningInfo_0000";
+}
+
+/**
+ * @tc.number: SUB_Service_WriteScannedInfoToList_0000
+ * @tc.name: SUB_Service_WriteScannedInfoToList_0000
+ * @tc.desc: 测试 WriteScannedInfoToList 接口
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: issueIAKC3I
+ */
+HWTEST_F(ServiceTest, SUB_Service_WriteScannedInfoToList_0000, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_WriteScannedInfoToList_0000";
+    try {
+        ASSERT_TRUE(service != nullptr);
+        auto ret = service->bundleDataSizeList_.size();
+        string bundleName = BUNDLE_NAME;
+        int64_t dataSize = 1;
+        int64_t incDataSize = 1;
+        service->WriteScannedInfoToList(bundleName, dataSize, incDataSize);
+        EXPECT_EQ(service->bundleDataSizeList_.size(), ret + 1);
+        service->bundleDataSizeList_.clear();
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by WriteScannedInfoToList.";
+    }
+    GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_WriteScannedInfoToList_0000";
+}
+
+/**
+ * @tc.number: SUB_Service_GetPrecisesSize_0000
+ * @tc.name: SUB_Service_GetPrecisesSize_0000
+ * @tc.desc: 测试 GetPrecisesSize 接口
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: issueIAKC3I
+ */
+HWTEST_F(ServiceTest, SUB_Service_GetPrecisesSize_0000, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_GetPrecisesSize_0000";
+    try {
+        vector<BIncrementalData> bundleNameList;
+        BIncrementalData data;
+        data.bundleName = BUNDLE_NAME;
+        data.lastIncrementalTime = 0;
+        bundleNameList.push_back(data);
+        string scanning = "";
+        BJsonUtil::BundleDetailInfo info;
+        info.bundleIndex = 1;
+        EXPECT_CALL(*jsonUtil, ParseBundleNameIndexStr(_)).WillOnce(Return(info));
+        EXPECT_CALL(*sms, GetBundleStatsForIncrease(_, _, _, _, _)).WillOnce(Return(0));
+        EXPECT_CALL(*param, GetBackupDebugOverrideAccount())
+            .WillOnce(Return(make_pair<bool, int32_t>(true, DEBUG_ID + 1)));
+        service->GetPrecisesSize(bundleNameList, scanning);
+        EXPECT_EQ(service->bundleDataSizeList_.size(), 0);
+        service->bundleDataSizeList_.clear();
+
+        vector<BIncrementalData> bundleNameListTwo;
+        BIncrementalData dataTwo;
+        dataTwo.bundleName = BUNDLE_NAME;
+        dataTwo.lastIncrementalTime = 1;
+        bundleNameListTwo.push_back(dataTwo);
+        EXPECT_CALL(*jsonUtil, ParseBundleNameIndexStr(_)).WillOnce(Return(info));
+        EXPECT_CALL(*sms, GetBundleStatsForIncrease(_, _, _, _, _)).WillOnce(Return(0));
+        EXPECT_CALL(*param, GetBackupDebugOverrideAccount())
+            .WillOnce(Return(make_pair<bool, int32_t>(true, DEBUG_ID + 1)));
+        service->GetPrecisesSize(bundleNameListTwo, scanning);
+        EXPECT_EQ(service->bundleDataSizeList_.size(), 0);
+        service->bundleDataSizeList_.clear();
+
+        EXPECT_CALL(*jsonUtil, ParseBundleNameIndexStr(_)).WillOnce(Return(info));
+        EXPECT_CALL(*sms, GetBundleStatsForIncrease(_, _, _, _, _)).WillOnce(Return(1));
+        EXPECT_CALL(*param, GetBackupDebugOverrideAccount())
+            .WillOnce(Return(make_pair<bool, int32_t>(true, DEBUG_ID + 1)));
+        service->GetPrecisesSize(bundleNameListTwo, scanning);
+        EXPECT_EQ(service->bundleDataSizeList_.size(), 1);
+        service->bundleDataSizeList_.clear();
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by GetPrecisesSize.";
+    }
+    GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_GetPrecisesSize_0000";
+}
+
+/**
+ * @tc.number: SUB_Service_GetPrecisesSize_0100
+ * @tc.name: SUB_Service_GetPrecisesSize_0100
+ * @tc.desc: 测试 GetPrecisesSize 接口
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: issueIAKC3I
+ */
+HWTEST_F(ServiceTest, SUB_Service_GetPrecisesSize_0100, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_GetPrecisesSize_0100";
+    try {
+        string scanning = "";
+        BJsonUtil::BundleDetailInfo info;
+        info.bundleIndex = 0;
+        vector<BIncrementalData> bundleNameListTwo;
+        BIncrementalData dataTwo;
+        dataTwo.bundleName = BUNDLE_NAME;
+        dataTwo.lastIncrementalTime = 1;
+        bundleNameListTwo.push_back(dataTwo);
+        EXPECT_CALL(*jsonUtil, ParseBundleNameIndexStr(_)).WillOnce(Return(info))
+            .WillOnce(Return(info)).WillOnce(Return(info));
+        EXPECT_CALL(*sms, GetBundleStatsForIncrease(_, _, _, _, _)).WillOnce(Return(0))
+            .WillOnce(Return(0)).WillOnce(Return(0));
+        EXPECT_CALL(*param, GetBackupDebugOverrideAccount())
+            .WillOnce(Return(make_pair<bool, int32_t>(true, DEBUG_ID + 1)))
+            .WillOnce(Return(make_pair<bool, int32_t>(true, DEBUG_ID + 1)))
+            .WillOnce(Return(make_pair<bool, int32_t>(true, DEBUG_ID + 1)));
+        service->GetPrecisesSize(bundleNameListTwo, scanning);
+        EXPECT_EQ(service->bundleDataSizeList_.size(), 0);
+        service->bundleDataSizeList_.clear();
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by GetPrecisesSize.";
+    }
+    GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_GetPrecisesSize_0100";
+}
+
+/**
+ * @tc.number: SUB_Service_GetPresumablySize_0000
+ * @tc.name: SUB_Service_GetPresumablySize_0000
+ * @tc.desc: 测试 GetPresumablySize 接口
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: issueIAKC3I
+ */
+HWTEST_F(ServiceTest, SUB_Service_GetPresumablySize_0000, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_GetPresumablySize_0000";
+    try {
+        auto ret = service->bundleDataSizeList_.size();
+        vector<BIncrementalData> bundleNameList;
+        BIncrementalData data;
+        data.bundleName = BUNDLE_NAME;
+        data.lastIncrementalTime = 0;
+        bundleNameList.push_back(data);
+        string scanning = "";
+        EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(true));
+        EXPECT_CALL(*param, GetBackupDebugOverrideAccount())
+            .WillOnce(Return(make_pair<bool, int32_t>(true, DEBUG_ID + 1)));
+        service->GetPresumablySize(bundleNameList, scanning);
+        EXPECT_EQ(service->bundleDataSizeList_.size(), ret + 1);
+        service->bundleDataSizeList_.clear();
+
+        EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(false));
+        EXPECT_CALL(*bms, GetBundleDataSize(_, _)).WillOnce(Return(0));
+        EXPECT_CALL(*param, GetBackupDebugOverrideAccount())
+            .WillOnce(Return(make_pair<bool, int32_t>(true, DEBUG_ID + 1)));
+        service->GetPresumablySize(bundleNameList, scanning);
+        EXPECT_EQ(service->bundleDataSizeList_.size(), 1);
+        service->bundleDataSizeList_.clear();
+
+        EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(false));
+        EXPECT_CALL(*bms, GetBundleDataSize(_, _)).WillOnce(Return(1));
+        EXPECT_CALL(*param, GetBackupDebugOverrideAccount())
+            .WillOnce(Return(make_pair<bool, int32_t>(true, DEBUG_ID + 1)))
+            .WillOnce(Return(make_pair<bool, int32_t>(true, DEBUG_ID + 1)));
+        service->GetPresumablySize(bundleNameList, scanning);
+        EXPECT_EQ(service->bundleDataSizeList_.size(), 1);
+        service->bundleDataSizeList_.clear();
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by GetPresumablySize.";
+    }
+    GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_GetPresumablySize_0000";
+}
+
+/**
+ * @tc.number: SUB_Service_GetDataSizeStepByStep_0000
+ * @tc.name: SUB_Service_GetDataSizeStepByStep_0000
+ * @tc.desc: 测试 GetDataSizeStepByStep 接口
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: issueIAKC3I
+ */
+HWTEST_F(ServiceTest, SUB_Service_GetDataSizeStepByStep_0000, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_GetDataSizeStepByStep_0000";
+    try {
+        bool isPreciseScan = false;
+        vector<BIncrementalData> bundleNameList;
+        string scanning = "";
+        EXPECT_CALL(*task, AddTask(_)).WillOnce(WithArgs<0>(Invoke([](const ThreadPool::Task &f) {
+            f();
+        })));
+        service->GetDataSizeStepByStep(isPreciseScan, bundleNameList, scanning);
+        EXPECT_TRUE(true);
+
+        isPreciseScan = true;
+                EXPECT_CALL(*task, AddTask(_)).WillOnce(WithArgs<0>(Invoke([](const ThreadPool::Task &f) {
+            f();
+        })));
+        service->GetDataSizeStepByStep(isPreciseScan, bundleNameList, scanning);
+        EXPECT_TRUE(true);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by GetDataSizeStepByStep.";
+    }
+    GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_GetDataSizeStepByStep_0000";
 }
\ No newline at end of file