diff --git a/tests/mock/utils_mock/include/b_jsonutil_mock.h b/tests/mock/utils_mock/include/b_jsonutil_mock.h
index 850c47a04644523a61faf5592767d689c6794225..01cfaff0023c242918b69d5c6d543442caf5daf4 100644
--- a/tests/mock/utils_mock/include/b_jsonutil_mock.h
+++ b/tests/mock/utils_mock/include/b_jsonutil_mock.h
@@ -28,11 +28,16 @@ public:
         const std::vector<std::string>&, const std::vector<std::string>&, std::vector<std::string>&, int32_t,
         std::map<std::string, bool>&) = 0;
     virtual void ParseBundleInfoJson(const std::string&, std::vector<BJsonUtil::BundleDetailInfo>&,
-        BJsonUtil::BundleDetailInfo, bool&) = 0;
+        BJsonUtil::BundleDetailInfo, bool&, int32_t) = 0;
     virtual bool FindBundleInfoByName(std::map<std::string, std::vector<BJsonUtil::BundleDetailInfo>>&, std::string&,
         const std::string&, BJsonUtil::BundleDetailInfo&) = 0;
-    virtual bool BuildRestoreErrInfo(std::string&, int, std::string) = 0;
+    virtual bool BuildExtensionErrInfo(std::string&, int, std::string) = 0;
     virtual std::string BuildBundleNameIndexInfo(const std::string&, int) = 0;
+    virtual bool BuildExtensionErrInfo(std::string&, std::map<std::string, std::vector<int>>) = 0;
+    virtual bool BuildOnProcessRetInfo(std::string&, std::string) = 0;
+    virtual bool BuildOnProcessErrInfo(std::string&, std::string, int) = 0;
+    virtual bool BuildBundleInfoJson(int32_t, std::string&) = 0;
+    virtual bool HasUnicastInfo(std::string&) = 0;
 public:
     BBJsonUtil() = default;
     virtual ~BBJsonUtil() = default;
@@ -47,11 +52,16 @@ public:
         ((const std::vector<std::string>&), (const std::vector<std::string>&), (std::vector<std::string>&), int32_t,
         (std::map<std::string, bool>&)));
     MOCK_METHOD(void, ParseBundleInfoJson, (const std::string&, (std::vector<BJsonUtil::BundleDetailInfo>&),
-        BJsonUtil::BundleDetailInfo, bool&));
+        BJsonUtil::BundleDetailInfo, bool&, int32_t));
     MOCK_METHOD(bool, FindBundleInfoByName, ((std::map<std::string, std::vector<BJsonUtil::BundleDetailInfo>>&),
         std::string&, const std::string&, BJsonUtil::BundleDetailInfo&));
-    MOCK_METHOD(bool, BuildRestoreErrInfo, (std::string&, int, std::string));
+    MOCK_METHOD(bool, BuildExtensionErrInfo, (std::string&, int, std::string));
     MOCK_METHOD(std::string, BuildBundleNameIndexInfo, (const std::string&, int));
+    MOCK_METHOD(bool, BuildExtensionErrInfo, (std::string&, (std::map<std::string, std::vector<int>>)));
+    MOCK_METHOD(bool, BuildOnProcessRetInfo, (std::string&, std::string));
+    MOCK_METHOD(bool, BuildOnProcessErrInfo, (std::string&, std::string, int));
+    MOCK_METHOD(bool, BuildBundleInfoJson, (int32_t, std::string&));
+    MOCK_METHOD(bool, HasUnicastInfo, (std::string&));
 };
 } // namespace OHOS::FileManagement::Backup
 #endif // OHOS_FILEMGMT_BACKUP_B_JSONUTIL_MOCK_MOCK_H
diff --git a/tests/mock/utils_mock/src/b_jsonutil_mock.cpp b/tests/mock/utils_mock/src/b_jsonutil_mock.cpp
index 5ab6814a4f1a85bcc164f62366bff4b5a1ed3373..8d802d4186c04b7c4b62d8a26745208ce491ebb1 100644
--- a/tests/mock/utils_mock/src/b_jsonutil_mock.cpp
+++ b/tests/mock/utils_mock/src/b_jsonutil_mock.cpp
@@ -32,9 +32,9 @@ std::map<std::string, std::vector<BJsonUtil::BundleDetailInfo>> BJsonUtil::Build
 }
 
 void BJsonUtil::ParseBundleInfoJson(const std::string &bundleInfo, std::vector<BundleDetailInfo> &bundleDetails,
-    BJsonUtil::BundleDetailInfo bundleDetailInfo, bool &isClearData)
+    BJsonUtil::BundleDetailInfo bundleDetailInfo, bool &isClearData, int32_t userId)
 {
-    BBJsonUtil::jsonUtil->ParseBundleInfoJson(bundleInfo, bundleDetails, bundleDetailInfo, isClearData);
+    BBJsonUtil::jsonUtil->ParseBundleInfoJson(bundleInfo, bundleDetails, bundleDetailInfo, isClearData, userId);
 }
 
 bool BJsonUtil::FindBundleInfoByName(std::map<std::string, std::vector<BundleDetailInfo>> &bundleNameDetailsMap,
@@ -43,13 +43,33 @@ bool BJsonUtil::FindBundleInfoByName(std::map<std::string, std::vector<BundleDet
     return BBJsonUtil::jsonUtil->FindBundleInfoByName(bundleNameDetailsMap, bundleName, jobType, bundleDetail);
 }
 
-bool BJsonUtil::BuildRestoreErrInfo(std::string &jsonStr, int errCode, std::string errMsg)
+bool BJsonUtil::BuildExtensionErrInfo(std::string &jsonStr, int errCode, std::string errMsg)
 {
-    return BBJsonUtil::jsonUtil->BuildRestoreErrInfo(jsonStr, errCode, errMsg);
+    return BBJsonUtil::jsonUtil->BuildExtensionErrInfo(jsonStr, errCode, errMsg);
 }
 
 std::string BJsonUtil::BuildBundleNameIndexInfo(const std::string &bundleName, int appIndex)
 {
     return BBJsonUtil::jsonUtil->BuildBundleNameIndexInfo(bundleName, appIndex);
 }
+
+bool BJsonUtil::BuildExtensionErrInfo(std::string &jsonStr, std::map<std::string, std::vector<int>> errFileInfo)
+{
+    return BBJsonUtil::jsonUtil->BuildExtensionErrInfo(jsonStr, errFileInfo);
+}
+
+bool BJsonUtil::BuildOnProcessRetInfo(std::string &jsonStr, std::string onProcessRet)
+{
+    return BBJsonUtil::jsonUtil->BuildOnProcessRetInfo(jsonStr, onProcessRet);
+}
+
+bool BJsonUtil::BuildOnProcessErrInfo(std::string &reportInfo, std::string path, int err)
+{
+    return BBJsonUtil::jsonUtil->BuildOnProcessErrInfo(reportInfo, path, err);
+}
+
+bool BJsonUtil::BuildBundleInfoJson(int32_t userId, string &detailInfo)
+{
+    return BBJsonUtil::jsonUtil->BuildBundleInfoJson(userId, detailInfo);
+}
 }
\ No newline at end of file
diff --git a/tests/unittests/backup_sa/module_ipc/BUILD.gn b/tests/unittests/backup_sa/module_ipc/BUILD.gn
index aec9584b895bf60946f7261199326745ee7d4555..69039b760b43681ac393991815fddb7d918c1945 100644
--- a/tests/unittests/backup_sa/module_ipc/BUILD.gn
+++ b/tests/unittests/backup_sa/module_ipc/BUILD.gn
@@ -411,6 +411,7 @@ ohos_unittest("backup_service_incremental_test") {
     "${path_backup_mock}/module_ipc/src/svc_backup_connection_mock.cpp",
     "${path_backup_mock}/module_ipc/src/svc_session_manager_mock.cpp",
     "${path_backup_mock}/module_sched/sched_scheduler_mock.cpp",
+    "${path_backup_mock}/utils_mock/src/b_jsonutil_mock.cpp",
     "${path_backup_mock}/utils_mock/src/backup_para_mock.cpp",
     "${path_backup}/services/backup_sa/src/module_ipc/svc_extension_incremental_proxy.cpp",
     "${path_backup}/services/backup_sa/src/module_ipc/svc_extension_proxy.cpp",
diff --git a/tests/unittests/backup_sa/module_ipc/service_incremental_test.cpp b/tests/unittests/backup_sa/module_ipc/service_incremental_test.cpp
index f2742c473fef134a060e0bf2e92deabe025d037c..575e95cdd7dccbcb666aea4cee0585d8ed2c111f 100644
--- a/tests/unittests/backup_sa/module_ipc/service_incremental_test.cpp
+++ b/tests/unittests/backup_sa/module_ipc/service_incremental_test.cpp
@@ -605,4 +605,441 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_PublishSAIncrementalFile
     }
     GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_PublishSAIncrementalFile_0000";
 }
+
+/**
+ * @tc.number: SUB_ServiceIncremental_AppIncrementalFileReady_0000
+ * @tc.name: SUB_ServiceIncremental_AppIncrementalFileReady_0000
+ * @tc.desc: 测试 AppIncrementalFileReady 的正常/异常分支
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: issueIAKC3I
+ */
+HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_AppIncrementalFileReady_0000, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_AppIncrementalFileReady_0000";
+    try {
+        string fileName;
+        int32_t errCode = 0;
+        EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE));
+        EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
+        EXPECT_CALL(*srProxy, IncrementalRestoreOnFileReady(_, _, _, _, _)).WillOnce(Return());
+        auto ret = service->AppIncrementalFileReady(fileName, UniqueFd(-1), UniqueFd(-1), errCode);
+        EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
+
+        EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP));
+        EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
+        EXPECT_CALL(*srProxy, IncrementalBackupOnFileReady(_, _, _, _, _)).WillOnce(Return());
+        EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(false));
+        ret = service->AppIncrementalFileReady(fileName, UniqueFd(-1), UniqueFd(-1), errCode);
+        EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
+
+        fileName = BConstants::EXT_BACKUP_MANAGE;
+        EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP));
+        EXPECT_CALL(*session, OnBundleExtManageInfo(_, _)).WillOnce(Return(UniqueFd(-1)));
+        EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
+        EXPECT_CALL(*srProxy, IncrementalBackupOnFileReady(_, _, _, _, _)).WillOnce(Return());
+        EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(false));
+        ret = service->AppIncrementalFileReady(fileName, UniqueFd(-1), UniqueFd(-1), errCode);
+        EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by AppIncrementalFileReady.";
+    }
+    GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_AppIncrementalFileReady_0000";
+}
+
+/**
+ * @tc.number: SUB_ServiceIncremental_AppIncrementalFileReady_0100
+ * @tc.name: SUB_ServiceIncremental_AppIncrementalFileReady_0100
+ * @tc.desc: 测试 AppIncrementalFileReady 的正常/异常分支
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: issueIAKC3I
+ */
+HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_AppIncrementalFileReady_0100, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_AppIncrementalFileReady_0100";
+    try {
+        string fileName;
+        int32_t errCode = 0;
+        EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP));
+        EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
+        EXPECT_CALL(*srProxy, IncrementalBackupOnFileReady(_, _, _, _, _)).WillOnce(Return());
+        EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(true));
+        EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
+        EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(nullptr));
+        auto ret = service->AppIncrementalFileReady(fileName, UniqueFd(-1), UniqueFd(-1), errCode);
+        EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
+
+        EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP));
+        EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)).WillOnce(Return(srProxy));
+        EXPECT_CALL(*srProxy, IncrementalBackupOnFileReady(_, _, _, _, _)).WillOnce(Return());
+        EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(true));
+        EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
+        EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
+        EXPECT_CALL(*svcProxy, HandleClear()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
+        EXPECT_CALL(*session, StopFwkTimer(_)).WillOnce(Return(true));
+        EXPECT_CALL(*session, StopExtTimer(_)).WillOnce(Return(true));
+        EXPECT_CALL(*srProxy, IncrementalBackupOnBundleFinished(_, _)).WillOnce(Return());
+        EXPECT_CALL(*connect, DisconnectBackupExtAbility()).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
+        ret = service->AppIncrementalFileReady(fileName, UniqueFd(-1), UniqueFd(-1), errCode);
+        EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by AppIncrementalFileReady.";
+    }
+    GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_AppIncrementalFileReady_0100";
+}
+
+/**
+ * @tc.number: SUB_ServiceIncremental_AppIncrementalDone_0000
+ * @tc.name: SUB_ServiceIncremental_AppIncrementalDone_0000
+ * @tc.desc: 测试 AppIncrementalDone 的正常/异常分支
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: issueIAKC3I
+ */
+HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_AppIncrementalDone_0000, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_AppIncrementalDone_0000";
+    try {
+        int32_t errCode = BError(BError::Codes::OK).GetCode();
+        auto session_ = service->session_;
+        service->session_ = nullptr;
+        auto ret = service->AppIncrementalDone(errCode);
+        EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
+        service->session_ = session_;
+
+        EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(false));
+        ret = service->AppIncrementalDone(errCode);
+        EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
+
+        EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(true));
+        EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(nullptr));
+        ret = service->AppIncrementalDone(errCode);
+        EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
+
+        errCode = BError(BError::Codes::SA_INVAL_ARG).GetCode();
+        EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(false));
+        EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(nullptr));
+        ret = service->AppIncrementalDone(errCode);
+        EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by AppIncrementalDone.";
+    }
+    GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_AppIncrementalDone_0000";
+}
+
+/**
+ * @tc.number: SUB_ServiceIncremental_GetIncrementalFileHandle_0000
+ * @tc.name: SUB_ServiceIncremental_GetIncrementalFileHandle_0000
+ * @tc.desc: 测试 GetIncrementalFileHandle 的正常/异常分支
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: issueIAKC3I
+ */
+HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_GetIncrementalFileHandle_0000, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_GetIncrementalFileHandle_0000";
+    try {
+        string bundleName;
+        string fileName;
+        auto session_ = service->session_;
+        service->session_ = nullptr;
+        EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::RUNNING));
+        EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(nullptr));
+        auto ret = service->GetIncrementalFileHandle(bundleName, fileName);
+        EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
+        service->session_ = session_;
+
+        EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::RUNNING));
+        EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
+        EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(nullptr));
+        ret = service->GetIncrementalFileHandle(bundleName, fileName);
+        EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
+
+        EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::RUNNING));
+        EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
+        EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
+        EXPECT_CALL(*svcProxy, GetIncrementalFileHandle(_)).WillOnce(Return(0));
+        ret = service->GetIncrementalFileHandle(bundleName, fileName);
+        EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
+
+        EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::RUNNING));
+        EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
+        EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
+        EXPECT_CALL(*svcProxy, GetIncrementalFileHandle(_)).WillOnce(Return(1));
+        EXPECT_CALL(*param, GetBackupDebugOverrideAccount())
+            .WillOnce(Return(make_pair<bool, int32_t>(true, DEBUG_ID + 1)));
+        ret = service->GetIncrementalFileHandle(bundleName, fileName);
+        EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
+
+        EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::WAIT));
+        ret = service->GetIncrementalFileHandle(bundleName, fileName);
+        EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by GetIncrementalFileHandle.";
+    }
+    GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_GetIncrementalFileHandle_0000";
+}
+
+/**
+ * @tc.number: SUB_ServiceIncremental_IncrementalBackup_0000
+ * @tc.name: SUB_ServiceIncremental_IncrementalBackup_0000
+ * @tc.desc: 测试 IncrementalBackup 的正常/异常分支
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: issueIAKC3I
+ */
+HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_IncrementalBackup_0000, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_IncrementalBackup_0000";
+    try {
+        string bundleName;
+        EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED));
+        EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(nullptr));
+        EXPECT_THROW(service->IncrementalBackup(bundleName), BError);
+
+        EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED));
+        EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
+        EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(nullptr));
+        EXPECT_THROW(service->IncrementalBackup(bundleName), BError);
+
+        EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED));
+        EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
+        EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
+        auto ret = service->IncrementalBackup(bundleName);
+        EXPECT_FALSE(ret);
+
+        EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP));
+        EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
+        EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
+        EXPECT_CALL(*session, GetIsIncrementalBackup()).WillOnce(Return(true));
+        EXPECT_CALL(*session, GetClearDataFlag(_)).WillOnce(Return(false));
+        EXPECT_CALL(*svcProxy, IncrementalOnBackup(_)).WillOnce(Return(0));
+        EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
+        EXPECT_CALL(*srProxy, IncrementalBackupOnBundleStarted(_, _)).WillOnce(Return());
+        ret = service->IncrementalBackup(bundleName);
+        EXPECT_TRUE(ret);
+
+        EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP));
+        EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
+        EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
+        EXPECT_CALL(*session, GetIsIncrementalBackup()).WillOnce(Return(true));
+        EXPECT_CALL(*session, GetClearDataFlag(_)).WillOnce(Return(false));
+        EXPECT_CALL(*svcProxy, IncrementalOnBackup(_)).WillOnce(Return(1));
+        EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
+        EXPECT_CALL(*srProxy, IncrementalBackupOnBundleStarted(_, _)).WillOnce(Return());
+        ret = service->IncrementalBackup(bundleName);
+        EXPECT_TRUE(ret);
+
+        EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP));
+        EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
+        EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
+        EXPECT_CALL(*session, GetIsIncrementalBackup()).WillOnce(Return(false));
+        ret = service->IncrementalBackup(bundleName);
+        EXPECT_FALSE(ret);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by IncrementalBackup.";
+    }
+    GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_IncrementalBackup_0000";
+}
+
+/**
+ * @tc.number: SUB_ServiceIncremental_IncrementalBackup_0100
+ * @tc.name: SUB_ServiceIncremental_IncrementalBackup_0100
+ * @tc.desc: 测试 IncrementalBackup 的正常/异常分支
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: issueIAKC3I
+ */
+HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_IncrementalBackup_0100, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_IncrementalBackup_0100";
+    try {
+        string bundleName;
+        EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE));
+        EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
+        EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
+        EXPECT_CALL(*param, GetBackupOverrideIncrementalRestore()).WillOnce(Return(false));
+        auto ret = service->IncrementalBackup(bundleName);
+        EXPECT_FALSE(ret);
+
+        EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE));
+        EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
+        EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
+        EXPECT_CALL(*param, GetBackupOverrideIncrementalRestore()).WillOnce(Return(true));
+        EXPECT_CALL(*session, ValidRestoreDataType(_)).WillOnce(Return(false));
+        ret = service->IncrementalBackup(bundleName);
+        EXPECT_FALSE(ret);
+
+        set<string> fileNameVec { "fileName" };
+        EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE));
+        EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
+        EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
+        EXPECT_CALL(*param, GetBackupOverrideIncrementalRestore()).WillOnce(Return(true));
+        EXPECT_CALL(*session, ValidRestoreDataType(_)).WillOnce(Return(true));
+        EXPECT_CALL(*session, GetClearDataFlag(_)).WillOnce(Return(false));
+        EXPECT_CALL(*svcProxy, HandleRestore(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
+        EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
+        EXPECT_CALL(*srProxy, IncrementalRestoreOnBundleStarted(_, _)).WillOnce(Return());
+        EXPECT_CALL(*session, GetExtFileNameRequest(_)).WillOnce(Return(fileNameVec));
+        EXPECT_CALL(*svcProxy, GetIncrementalFileHandle(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
+        ret = service->IncrementalBackup(bundleName);
+        EXPECT_TRUE(ret);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by IncrementalBackup.";
+    }
+    GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_IncrementalBackup_0100";
+}
+
+/**
+ * @tc.number: SUB_ServiceIncremental_IncrementalBackup_0200
+ * @tc.name: SUB_ServiceIncremental_IncrementalBackup_0200
+ * @tc.desc: 测试 IncrementalBackup 的正常/异常分支
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: issueIAKC3I
+ */
+HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_IncrementalBackup_0200, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_IncrementalBackup_0200";
+    try {
+        string bundleName;
+        set<string> fileNameVec { "fileName" };
+        EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE));
+        EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect));
+        EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy));
+        EXPECT_CALL(*param, GetBackupOverrideIncrementalRestore()).WillOnce(Return(true));
+        EXPECT_CALL(*session, ValidRestoreDataType(_)).WillOnce(Return(true));
+        EXPECT_CALL(*session, GetClearDataFlag(_)).WillOnce(Return(false));
+        EXPECT_CALL(*svcProxy, HandleRestore(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
+        EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
+        EXPECT_CALL(*srProxy, IncrementalRestoreOnBundleStarted(_, _)).WillOnce(Return());
+        EXPECT_CALL(*session, GetExtFileNameRequest(_)).WillOnce(Return(fileNameVec));
+        EXPECT_CALL(*svcProxy, GetIncrementalFileHandle(_))
+            .WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG).GetCode()));
+        auto ret = service->IncrementalBackup(bundleName);
+        EXPECT_TRUE(ret);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by IncrementalBackup.";
+    }
+    GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_IncrementalBackup_0200";
+}
+
+/**
+ * @tc.number: SUB_ServiceIncremental_NotifyCallerCurAppIncrementDone_0000
+ * @tc.name: SUB_ServiceIncremental_NotifyCallerCurAppIncrementDone_0000
+ * @tc.desc: 测试 NotifyCallerCurAppIncrementDone 的正常/异常分支
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: issueIAKC3I
+ */
+HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_NotifyCallerCurAppIncrementDone_0000, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_NotifyCallerCurAppIncrementDone_0000";
+    try {
+        ErrCode errCode = 0;
+        string callerName;
+        EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED));
+        service->NotifyCallerCurAppIncrementDone(errCode, callerName);
+        EXPECT_TRUE(true);
+
+        EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP));
+        EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
+        EXPECT_CALL(*srProxy, IncrementalBackupOnBundleFinished(_, _)).WillOnce(Return());
+        service->NotifyCallerCurAppIncrementDone(errCode, callerName);
+        EXPECT_TRUE(true);
+
+        EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE));
+        EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy));
+        EXPECT_CALL(*srProxy, IncrementalRestoreOnBundleFinished(_, _)).WillOnce(Return());
+        service->NotifyCallerCurAppIncrementDone(errCode, callerName);
+        EXPECT_TRUE(true);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by NotifyCallerCurAppIncrementDone.";
+    }
+    GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_NotifyCallerCurAppIncrementDone_0200";
+}
+
+/**
+ * @tc.number: SUB_ServiceIncremental_SendUserIdToApp_0000
+ * @tc.name: SUB_ServiceIncremental_SendUserIdToApp_0000
+ * @tc.desc: 测试 SendUserIdToApp 的正常/异常分支
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: issueIAKC3I
+ */
+HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_SendUserIdToApp_0000, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_SendUserIdToApp_0000";
+    try {
+        string bundleName;
+        int32_t userId = 100;
+        auto session_ = service->session_;
+        service->session_ = nullptr;
+        service->SendUserIdToApp(bundleName, userId);
+        service->session_ = session_;
+        EXPECT_TRUE(true);
+
+        EXPECT_CALL(*jsonUtil, BuildBundleInfoJson(_, _)).WillOnce(Return(false));
+        service->SendUserIdToApp(bundleName, userId);
+        EXPECT_TRUE(true);
+
+        EXPECT_CALL(*jsonUtil, BuildBundleInfoJson(_, _)).WillOnce(Return(true));
+        service->SendUserIdToApp(bundleName, userId);
+        EXPECT_TRUE(true);
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by SendUserIdToApp.";
+    }
+    GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_SendUserIdToApp_0200";
+}
+
+/**
+ * @tc.number: SUB_ServiceIncremental_SetCurrentBackupSessProperties_0000
+ * @tc.name: SUB_ServiceIncremental_SetCurrentBackupSessProperties_0000
+ * @tc.desc: 测试 SetCurrentBackupSessProperties 的正常/异常分支
+ * @tc.size: MEDIUM
+ * @tc.type: FUNC
+ * @tc.level Level 1
+ * @tc.require: issueIAKC3I
+ */
+HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_SetCurrentBackupSessProperties_0000, TestSize.Level1)
+{
+    GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_SetCurrentBackupSessProperties_0000";
+    try {
+        vector<string> bundleNames { "bundleName" };
+        int32_t userId = 100;
+        auto session_ = service->session_;
+        service->session_ = nullptr;
+        EXPECT_CALL(*bms, IsUser0BundleName(_, _)).WillOnce(Return(false));
+        service->SetCurrentBackupSessProperties(bundleNames, userId);
+        EXPECT_TRUE(true);
+
+        EXPECT_CALL(*bms, IsUser0BundleName(_, _)).WillOnce(Return(true));
+        service->SetCurrentBackupSessProperties(bundleNames, userId);
+        EXPECT_TRUE(true);
+        service->session_ = session_;
+    } catch (...) {
+        EXPECT_TRUE(false);
+        GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by SetCurrentBackupSessProperties.";
+    }
+    GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_SetCurrentBackupSessProperties_0200";
+}
 }
\ No newline at end of file
diff --git a/utils/src/b_jsonutil/b_jsonutil.cpp b/utils/src/b_jsonutil/b_jsonutil.cpp
index 538c3e1be9c9c2c5082b03f1a2b823eb369aef0c..87e9bb10cdc287bebced2d868b7a6e8bebda4c81 100644
--- a/utils/src/b_jsonutil/b_jsonutil.cpp
+++ b/utils/src/b_jsonutil/b_jsonutil.cpp
@@ -348,9 +348,8 @@ bool BJsonUtil::BuildExtensionErrInfo(std::string &jsonStr, std::map<std::string
     cJSON_free(data);
     return true;
 }
-}
 
-bool OHOS::FileManagement::Backup::BJsonUtil::BuildOnProcessRetInfo(std::string &jsonStr, std::string onProcessRet)
+bool BJsonUtil::BuildOnProcessRetInfo(std::string &jsonStr, std::string onProcessRet)
 {
     cJSON *info = cJSON_CreateObject();
     if (info == nullptr) {
@@ -376,7 +375,7 @@ bool OHOS::FileManagement::Backup::BJsonUtil::BuildOnProcessRetInfo(std::string
     return true;
 }
 
-bool OHOS::FileManagement::Backup::BJsonUtil::BuildOnProcessErrInfo(std::string &reportInfo, std::string path, int err)
+bool BJsonUtil::BuildOnProcessErrInfo(std::string &reportInfo, std::string path, int err)
 {
     cJSON *info = cJSON_CreateObject();
     if (info == nullptr) {
@@ -411,7 +410,7 @@ bool OHOS::FileManagement::Backup::BJsonUtil::BuildOnProcessErrInfo(std::string
     return true;
 }
 
-bool OHOS::FileManagement::Backup::BJsonUtil::BuildBundleInfoJson(int32_t userId, string &detailInfo)
+bool BJsonUtil::BuildBundleInfoJson(int32_t userId, string &detailInfo)
 {
     cJSON *root = cJSON_CreateObject();
     if (root == nullptr) {
@@ -454,4 +453,5 @@ bool OHOS::FileManagement::Backup::BJsonUtil::BuildBundleInfoJson(int32_t userId
     cJSON_Delete(root);
     free(jsonStr);
     return true;
+}
 }
\ No newline at end of file