diff --git a/services/accesstokenmanager/main/cpp/include/database/access_token_db.h b/services/accesstokenmanager/main/cpp/include/database/access_token_db.h
index 58ee06f4bb04c2286f25a37c08171c5242ae6522..b12afa0a4c307aa77d9005472cd465f7d7d96a78 100644
--- a/services/accesstokenmanager/main/cpp/include/database/access_token_db.h
+++ b/services/accesstokenmanager/main/cpp/include/database/access_token_db.h
@@ -32,6 +32,18 @@ namespace Security {
 namespace AccessToken {
 static constexpr const char* PERM_DEF_VERSION = "permission_definition_version";
 
+typedef struct TypeDelInfo
+{
+    AtmDataType delType;
+    GenericValues delValue;
+} DelInfo;
+
+typedef struct TypeAddInfo
+{
+    AtmDataType addType;
+    std::vector<GenericValues> addValues;
+} AddInfo;
+
 class AccessTokenDb final {
 public:
     static AccessTokenDb& GetInstance();
@@ -40,9 +52,7 @@ public:
     int32_t Modify(const AtmDataType type, const GenericValues& modifyValue, const GenericValues& conditionValue);
     int32_t Find(AtmDataType type, const GenericValues& conditionValue, std::vector<GenericValues>& results);
     std::shared_ptr<NativeRdb::RdbStore> GetRdb();
-    int32_t DeleteAndInsertValues(
-        const std::vector<AtmDataType>& delDataTypes, const std::vector<GenericValues>& delValues,
-        const std::vector<AtmDataType>& addDataTypes, const std::vector<std::vector<GenericValues>>& addValues);
+    int32_t DeleteAndInsertValues(const std::vector<DelInfo>& delInfoVec, const std::vector<AddInfo>& addInfoVec);
 
 private:
     AccessTokenDb();
diff --git a/services/accesstokenmanager/main/cpp/include/service/accesstoken_manager_service.h b/services/accesstokenmanager/main/cpp/include/service/accesstoken_manager_service.h
index b94a93d697d479521a51561f1b696bb9de88dac8..c21f94d5262f461621feee539742e6a43b1dac17 100644
--- a/services/accesstokenmanager/main/cpp/include/service/accesstoken_manager_service.h
+++ b/services/accesstokenmanager/main/cpp/include/service/accesstoken_manager_service.h
@@ -25,8 +25,8 @@
 #ifdef EVENTHANDLER_ENABLE
 #include "access_event_handler.h"
 #endif
+#include "access_token_db.h"
 #include "access_token.h"
-#include "access_token_db_util.h"
 #include "generic_values.h"
 #include "hap_token_info.h"
 #include "iremote_object.h"
@@ -154,12 +154,9 @@ private:
         std::vector<GenericValues>& validValueList);
     void UpdateUndefinedInfoCache(const std::vector<GenericValues>& validValueList,
         std::vector<GenericValues>& stateValues, std::vector<GenericValues>& extendValues);
-    void HandleHapUndefinedInfo(const std::map<int32_t, int32_t>& tokenIdAplMap,
-        std::vector<AtmDataType>& deleteDataTypes, std::vector<GenericValues>& deleteValues,
-        std::vector<AtmDataType>& addDataTypes, std::vector<std::vector<GenericValues>>& addValues);
-    void UpdateDatabaseAsync(const std::vector<AtmDataType>& deleteDataTypes,
-        const std::vector<GenericValues>& deleteValues, const std::vector<AtmDataType>& addDataTypes,
-        const std::vector<std::vector<GenericValues>>& addValues);
+    void HandleHapUndefinedInfo(const std::map<int32_t, int32_t>& tokenIdAplMap, std::vector<DelInfo>& delInfoVec,
+        std::vector<AddInfo>& addInfoVec);
+    void UpdateDatabaseAsync(const std::vector<DelInfo>& delInfoVec, const std::vector<AddInfo>& addInfoVec);
     void HandlePermDefUpdate(const std::map<int32_t, int32_t>& tokenIdAplMap);
 
     ServiceRunningState state_;
diff --git a/services/accesstokenmanager/main/cpp/include/token/accesstoken_info_manager.h b/services/accesstokenmanager/main/cpp/include/token/accesstoken_info_manager.h
index d067a53479841461c897369022303bc765aa5054..3f87d9b76a567a383d6da0244e34526381c79fae 100644
--- a/services/accesstokenmanager/main/cpp/include/token/accesstoken_info_manager.h
+++ b/services/accesstokenmanager/main/cpp/include/token/accesstoken_info_manager.h
@@ -23,6 +23,7 @@
 #include <unordered_set>
 #include <vector>
 
+#include "access_token_db.h"
 #include "access_token.h"
 #include "atm_tools_param_info.h"
 #ifdef TOKEN_SYNC_ENABLE
@@ -115,8 +116,10 @@ private:
     std::string GetHapUniqueStr(const std::shared_ptr<HapTokenInfoInner>& info) const;
     std::string GetHapUniqueStr(const int& userID, const std::string& bundleName, const int& instIndex) const;
     int32_t RegisterTokenId(const HapInfoParams& info, AccessTokenID& tokenId);
-    void FillDelValues(AccessTokenID tokenID, bool isSystemRes, const std::vector<GenericValues>& permExtendValues,
-        const std::vector<GenericValues>& undefValues, std::vector<GenericValues>& deleteValues);
+    void GenerateAddInfoToVec(AtmDataType type, const std::vector<GenericValues>& addValues,
+        std::vector<AddInfo>& addInfoVec);
+    void GenerateDelInfoToVec(AtmDataType type, const GenericValues& delValue,
+        std::vector<DelInfo>& delInfoVec);
     void AddTokenIdToUndefValues(AccessTokenID tokenId, std::vector<GenericValues>& undefValues);
     int AddHapTokenInfoToDb(const std::shared_ptr<HapTokenInfoInner>& hapInfo, const std::string& appId,
         const HapPolicy& policy, bool isUpdate, const std::vector<GenericValues>& undefValues);
diff --git a/services/accesstokenmanager/main/cpp/src/database/access_token_db.cpp b/services/accesstokenmanager/main/cpp/src/database/access_token_db.cpp
index b7c17073d5eb5b686e2f26e42522edc988e3f3ae..39fc6f8966eb2a5d487024c7f46587c0746d68d8 100644
--- a/services/accesstokenmanager/main/cpp/src/database/access_token_db.cpp
+++ b/services/accesstokenmanager/main/cpp/src/database/access_token_db.cpp
@@ -400,9 +400,8 @@ int32_t AccessTokenDb::RestoreAndCommitIfCorrupt(const int32_t resultCode,
     return NativeRdb::E_OK;
 }
 
-int32_t AccessTokenDb::DeleteAndInsertValues(
-    const std::vector<AtmDataType>& delDataTypes, const std::vector<GenericValues>& delValues,
-    const std::vector<AtmDataType>& addDataTypes, const std::vector<std::vector<GenericValues>>& addValues)
+int32_t AccessTokenDb::DeleteAndInsertValues(const std::vector<DelInfo>& delInfoVec,
+    const std::vector<AddInfo>& addInfoVec)
 {
     int64_t beginTime = TimeUtil::GetCurrentTimestamp();
 
@@ -417,9 +416,9 @@ int32_t AccessTokenDb::DeleteAndInsertValues(
         db->BeginTransaction();
 
         int32_t res = 0;
-        size_t count = delDataTypes.size();
+        size_t count = delInfoVec.size();
         for (size_t i = 0; i < count; ++i) {
-            res = RemoveValues(delDataTypes[i], delValues[i]);
+            res = RemoveValues(delInfoVec[i].delType, delInfoVec[i].delValue);
             if (res != 0) {
                 db->RollBack();
                 LOGC(ATM_DOMAIN, ATM_TAG, "Remove values failed, res is %{public}d.", res);
@@ -427,9 +426,9 @@ int32_t AccessTokenDb::DeleteAndInsertValues(
             }
         }
 
-        count = addDataTypes.size();
+        count = addInfoVec.size();
         for (size_t i = 0; i < count; ++i) {
-            res = AddValues(addDataTypes[i], addValues[i]);
+            res = AddValues(addInfoVec[i].addType, addInfoVec[i].addValues);
             if (res != 0) {
                 db->RollBack();
                 LOGC(ATM_DOMAIN, ATM_TAG, "Add values failed, res is %{public}d.", res);
diff --git a/services/accesstokenmanager/main/cpp/src/service/accesstoken_manager_service.cpp b/services/accesstokenmanager/main/cpp/src/service/accesstoken_manager_service.cpp
index 36c4d4785de50f573170a1bfbc6fc6d5042b5143..3ec32b476786c34d8972c880d52f1cc7c14298a5 100644
--- a/services/accesstokenmanager/main/cpp/src/service/accesstoken_manager_service.cpp
+++ b/services/accesstokenmanager/main/cpp/src/service/accesstoken_manager_service.cpp
@@ -550,7 +550,7 @@ int32_t AccessTokenManagerService::SetPermissionStatusWithPolicy(
     AccessTokenID tokenID, const std::vector<std::string>& permissionList, int32_t status, uint32_t flag)
 {
     LOGI(ATM_DOMAIN, ATM_TAG, "tokenID: %{public}d, permList size:%{public}zu, status: %{public}d, flag: %{public}u.",
-         tokenID, permissionList.size(), status, flag);
+        tokenID, permissionList.size(), status, flag);
     AccessTokenID callingTokenID = IPCSkeleton::GetCallingTokenID();
     if ((this->GetTokenType(callingTokenID) == TOKEN_HAP) && (!IsSystemAppCalling())) {
         return AccessTokenError::ERR_NOT_SYSTEM_APP;
@@ -1534,8 +1534,7 @@ bool AccessTokenManagerService::IsPermissionValid(int32_t hapApl, const Permissi
 }
 
 void AccessTokenManagerService::HandleHapUndefinedInfo(const std::map<int32_t, int32_t>& tokenIdAplMap,
-    std::vector<AtmDataType>& deleteDataTypes, std::vector<GenericValues>& deleteValues,
-    std::vector<AtmDataType>& addDataTypes, std::vector<std::vector<GenericValues>>& addValues)
+    std::vector<DelInfo>& delInfoVec, std::vector<AddInfo>& addInfoVec)
 {
     GenericValues conditionValue;
     std::vector<GenericValues> results;
@@ -1557,25 +1556,28 @@ void AccessTokenManagerService::HandleHapUndefinedInfo(const std::map<int32_t, i
     std::vector<GenericValues> extendValues;
     UpdateUndefinedInfoCache(validValueList, stateValues, extendValues);
 
+    DelInfo delInfo;
     for (const auto& value : validValueList) {
-        deleteDataTypes.emplace_back(AtmDataType::ACCESSTOKEN_HAP_UNDEFINE_INFO);
-        deleteValues.emplace_back(value);
+        delInfo.delType = AtmDataType::ACCESSTOKEN_HAP_UNDEFINE_INFO;
+        delInfo.delValue = value;
+        delInfoVec.emplace_back(delInfo);
     }
 
-    addDataTypes.emplace_back(AtmDataType::ACCESSTOKEN_PERMISSION_STATE);
-    addDataTypes.emplace_back(AtmDataType::ACCESSTOKEN_PERMISSION_EXTEND_VALUE);
-    addValues.emplace_back(stateValues);
-    addValues.emplace_back(extendValues);
+    AddInfo addInfo;
+    addInfo.addType = AtmDataType::ACCESSTOKEN_PERMISSION_STATE;
+    addInfo.addValues = stateValues;
+    addInfoVec.emplace_back(addInfo);
+    addInfo.addType = AtmDataType::ACCESSTOKEN_PERMISSION_EXTEND_VALUE;
+    addInfo.addValues = extendValues;
+    addInfoVec.emplace_back(addInfo);
 }
 
-void AccessTokenManagerService::UpdateDatabaseAsync(const std::vector<AtmDataType>& deleteDataTypes,
-    const std::vector<GenericValues>& deleteValues, const std::vector<AtmDataType>& addDataTypes,
-    const std::vector<std::vector<GenericValues>>& addValues)
+void AccessTokenManagerService::UpdateDatabaseAsync(const std::vector<DelInfo>& delInfoVec,
+    const std::vector<AddInfo>& addInfoVec)
 {
-    auto task = [deleteDataTypes, deleteValues, addDataTypes, addValues]() {
+    auto task = [delInfoVec, addInfoVec]() {
         LOGI(ATM_DOMAIN, ATM_TAG, "Entry!");
-        (void)AccessTokenDb::GetInstance().DeleteAndInsertValues(deleteDataTypes, deleteValues, addDataTypes,
-            addValues);
+        (void)AccessTokenDb::GetInstance().DeleteAndInsertValues(delInfoVec, addInfoVec);
     };
     std::thread updateDbThread(task);
     updateDbThread.detach();
@@ -1608,24 +1610,24 @@ void AccessTokenManagerService::HandlePermDefUpdate(const std::map<int32_t, int3
         GenericValues addValue;
         addValue.Put(TokenFiledConst::FIELD_NAME, PERM_DEF_VERSION);
         addValue.Put(TokenFiledConst::FIELD_VALUE, std::string(curPermDefVersion));
-        std::vector<GenericValues> values;
-        values.emplace_back(addValue);
+        DelInfo delInfo;
+        delInfo.delType = AtmDataType::ACCESSTOKEN_SYSTEM_CONFIG;
+        delInfo.delValue = delValue;
+        AddInfo addInfo;
+        addInfo.addType = AtmDataType::ACCESSTOKEN_SYSTEM_CONFIG;
+        addInfo.addValues.emplace_back(addValue);
 
         // update or insert permission define version to db
-        std::vector<AtmDataType> deleteDataTypes;
-        deleteDataTypes.emplace_back(AtmDataType::ACCESSTOKEN_SYSTEM_CONFIG);
-        std::vector<GenericValues> deleteValues;
-        deleteValues.emplace_back(delValue);
-        std::vector<AtmDataType> addDataTypes;
-        addDataTypes.emplace_back(AtmDataType::ACCESSTOKEN_SYSTEM_CONFIG);
-        std::vector<std::vector<GenericValues>> addValues;
-        addValues.emplace_back(values);
+        std::vector<DelInfo> delInfoVec;
+        delInfoVec.emplace_back(delInfo);
+        std::vector<AddInfo> addInfoVec;
+        addInfoVec.emplace_back(addInfo);
 
         if (!dbPermDefVersion.empty()) { // dbPermDefVersion empty means undefine table is empty
-            HandleHapUndefinedInfo(tokenIdAplMap, deleteDataTypes, deleteValues, addDataTypes, addValues);
+            HandleHapUndefinedInfo(tokenIdAplMap, delInfoVec, addInfoVec);
         }
 
-        UpdateDatabaseAsync(deleteDataTypes, deleteValues, addDataTypes, addValues);
+        UpdateDatabaseAsync(delInfoVec, addInfoVec);
     }
 }
 
diff --git a/services/accesstokenmanager/main/cpp/src/token/accesstoken_info_manager.cpp b/services/accesstokenmanager/main/cpp/src/token/accesstoken_info_manager.cpp
index f10f89e4e89cb20e9d03a2cdc58bf25b6f4cdc5e..2596ce719c3c9f6edaaeb1c7f574d8800bd7ba73 100644
--- a/services/accesstokenmanager/main/cpp/src/token/accesstoken_info_manager.cpp
+++ b/services/accesstokenmanager/main/cpp/src/token/accesstoken_info_manager.cpp
@@ -22,7 +22,6 @@
 #include <unistd.h>
 #include <securec.h>
 #include "access_token.h"
-#include "access_token_db.h"
 #include "accesstoken_dfx_define.h"
 #include "accesstoken_id_manager.h"
 #include "accesstoken_common_log.h"
@@ -1049,27 +1048,22 @@ static void GetUserGrantPermFromDef(const std::vector<PermissionDef>& permList,
     }
 }
 
-void AccessTokenInfoManager::FillDelValues(AccessTokenID tokenID, bool isSystemRes,
-    const std::vector<GenericValues>& permExtendValues, const std::vector<GenericValues>& undefValues,
-    std::vector<GenericValues>& deleteValues)
+void AccessTokenInfoManager::GenerateAddInfoToVec(AtmDataType type, const std::vector<GenericValues>& addValues,
+    std::vector<AddInfo>& addInfoVec)
 {
-    GenericValues conditionValue;
-    conditionValue.Put(TokenFiledConst::FIELD_TOKEN_ID, static_cast<int32_t>(tokenID));
-    deleteValues.emplace_back(conditionValue); // hap_token_info_table
-    deleteValues.emplace_back(conditionValue); // permission_state_table
-
-    if (isSystemRes) {
-        deleteValues.emplace_back(conditionValue); // permission_definition_table
-    }
-
-    if (!permExtendValues.empty()) {
-        deleteValues.emplace_back(conditionValue); // permission_extend_value_table
-    }
+    AddInfo addInfo;
+    addInfo.addType = type;
+    addInfo.addValues = addValues;
+    addInfoVec.emplace_back(addInfo);
+}
 
-    if (!undefValues.empty()) {
-        deleteValues.emplace_back(conditionValue); // hap_undefine_info_table
-    }
-    return;
+void AccessTokenInfoManager::GenerateDelInfoToVec(AtmDataType type, const GenericValues& delValue,
+    std::vector<DelInfo>& delInfoVec)
+{
+    DelInfo delInfo;
+    delInfo.delType = type;
+    delInfo.delValue = delValue;
+    delInfoVec.emplace_back(delInfo);
 }
 
 int AccessTokenInfoManager::AddHapTokenInfoToDb(const std::shared_ptr<HapTokenInfoInner>& hapInfo,
@@ -1086,52 +1080,39 @@ int AccessTokenInfoManager::AddHapTokenInfoToDb(const std::shared_ptr<HapTokenIn
     AccessTokenID tokenID = hapInfo->GetTokenID();
     bool isSystemRes = IsSystemResource(hapInfo->GetBundleName());
 
+    std::vector<AddInfo> addInfoVec;
+    GenerateAddInfoToVec(AtmDataType::ACCESSTOKEN_HAP_UNDEFINE_INFO, undefValues, addInfoVec);
+
     std::vector<GenericValues> hapInfoValues; // get new hap token info from cache
     hapInfo->StoreHapInfo(hapInfoValues, appId, policy.apl);
+    GenerateAddInfoToVec(AtmDataType::ACCESSTOKEN_HAP_INFO, hapInfoValues, addInfoVec);
 
     std::vector<GenericValues> permStateValues; // get new permission status from cache if exist
     hapInfo->StorePermissionPolicy(permStateValues);
+    GenerateAddInfoToVec(AtmDataType::ACCESSTOKEN_PERMISSION_STATE, permStateValues, addInfoVec);
 
-    std::vector<GenericValues> permExtendValues; // get new extend permission value
     std::vector<PermissionWithValue> extendedPermList;
     PermissionDataBrief::GetInstance().GetExetendedValueList(tokenID, extendedPermList);
-
+    std::vector<GenericValues> permExtendValues; // get new extend permission value
     GeneratePermExtendValues(tokenID, extendedPermList, permExtendValues);
-
-    std::vector<AtmDataType> addDataTypes;
-    addDataTypes.emplace_back(AtmDataType::ACCESSTOKEN_HAP_INFO);
-    addDataTypes.emplace_back(AtmDataType::ACCESSTOKEN_PERMISSION_STATE);
-
-    std::vector<std::vector<GenericValues>> addValues;
-    addValues.emplace_back(hapInfoValues);
-    addValues.emplace_back(permStateValues);
+    GenerateAddInfoToVec(AtmDataType::ACCESSTOKEN_PERMISSION_EXTEND_VALUE, permExtendValues, addInfoVec);
 
     if (isSystemRes) {
         std::vector<GenericValues> permDefValues;
         GetUserGrantPermFromDef(policy.permList, tokenID, permDefValues);
-        addDataTypes.emplace_back(AtmDataType::ACCESSTOKEN_PERMISSION_DEF);
-        addValues.emplace_back(permDefValues);
-    }
-
-    if (!permExtendValues.empty()) {
-        addDataTypes.emplace_back(AtmDataType::ACCESSTOKEN_PERMISSION_EXTEND_VALUE);
-        addValues.emplace_back(permExtendValues);
-    }
-
-    if (!undefValues.empty()) {
-        addDataTypes.emplace_back(AtmDataType::ACCESSTOKEN_HAP_UNDEFINE_INFO);
-        addValues.emplace_back(undefValues);
+        GenerateAddInfoToVec(AtmDataType::ACCESSTOKEN_PERMISSION_DEF, permDefValues, addInfoVec);
     }
-
-    std::vector<AtmDataType> delDataTypes;
-    std::vector<GenericValues> deleteValues;
-
+    
+    std::vector<DelInfo> delInfoVec;
+    GenericValues delValue;
+    delValue.Put(TokenFiledConst::FIELD_TOKEN_ID, static_cast<int32_t>(tokenID));
     if (isUpdate) { // udapte: delete and add; otherwise add only
-        delDataTypes.assign(addDataTypes.begin(), addDataTypes.end());
-        FillDelValues(tokenID, isSystemRes, permExtendValues, undefValues, deleteValues);
+        for (auto const& addInfo : addInfoVec) {
+            GenerateDelInfoToVec(addInfo.addType, delValue, delInfoVec);
+        }
     }
 
-    return AccessTokenDb::GetInstance().DeleteAndInsertValues(delDataTypes, deleteValues, addDataTypes, addValues);
+    return AccessTokenDb::GetInstance().DeleteAndInsertValues(delInfoVec, addInfoVec);
 }
 
 int AccessTokenInfoManager::RemoveHapTokenInfoFromDb(const std::shared_ptr<HapTokenInfoInner>& info)
@@ -1140,27 +1121,18 @@ int AccessTokenInfoManager::RemoveHapTokenInfoFromDb(const std::shared_ptr<HapTo
     GenericValues condition;
     condition.Put(TokenFiledConst::FIELD_TOKEN_ID, static_cast<int32_t>(tokenID));
 
-    std::vector<AtmDataType> deleteDataTypes;
-    deleteDataTypes.emplace_back(AtmDataType::ACCESSTOKEN_HAP_INFO);
-    deleteDataTypes.emplace_back(AtmDataType::ACCESSTOKEN_PERMISSION_STATE);
-    deleteDataTypes.emplace_back(AtmDataType::ACCESSTOKEN_PERMISSION_EXTEND_VALUE);
-    deleteDataTypes.emplace_back(AtmDataType::ACCESSTOKEN_HAP_UNDEFINE_INFO);
-
-    std::vector<GenericValues> deleteValues;
-    deleteValues.emplace_back(condition);
-    deleteValues.emplace_back(condition);
-    deleteValues.emplace_back(condition);
-    deleteValues.emplace_back(condition);
+    std::vector<DelInfo> delInfoVec;
+    GenerateDelInfoToVec(AtmDataType::ACCESSTOKEN_HAP_INFO, condition, delInfoVec);
+    GenerateDelInfoToVec(AtmDataType::ACCESSTOKEN_PERMISSION_STATE, condition, delInfoVec);
+    GenerateDelInfoToVec(AtmDataType::ACCESSTOKEN_PERMISSION_EXTEND_VALUE, condition, delInfoVec);
+    GenerateDelInfoToVec(AtmDataType::ACCESSTOKEN_HAP_UNDEFINE_INFO, condition, delInfoVec);
 
     if (IsSystemResource(info->GetBundleName())) {
-        deleteDataTypes.emplace_back(AtmDataType::ACCESSTOKEN_PERMISSION_DEF);
-        deleteValues.emplace_back(condition);
+        GenerateDelInfoToVec(AtmDataType::ACCESSTOKEN_PERMISSION_DEF, condition, delInfoVec);
     }
 
-    std::vector<AtmDataType> addDataTypes;
-    std::vector<std::vector<GenericValues>> addValues;
-    int32_t ret = AccessTokenDb::GetInstance().DeleteAndInsertValues(deleteDataTypes, deleteValues, addDataTypes,
-        addValues);
+    std::vector<AddInfo> addInfoVec;
+    int32_t ret = AccessTokenDb::GetInstance().DeleteAndInsertValues(delInfoVec, addInfoVec);
     if (ret != RET_SUCCESS) {
         LOGC(ATM_DOMAIN, ATM_TAG, "Id %{public}d DeleteAndInsertHap failed, ret %{public}d.", tokenID, ret);
         return ret;
@@ -1752,20 +1724,17 @@ int32_t AccessTokenInfoManager::AddPermRequestToggleStatusToDb(
     condition.Put(TokenFiledConst::FIELD_USER_ID, userID);
     condition.Put(TokenFiledConst::FIELD_PERMISSION_NAME, permissionName);
 
-    std::vector<AtmDataType> dataTypes;
-    dataTypes.emplace_back(AtmDataType::ACCESSTOKEN_PERMISSION_REQUEST_TOGGLE_STATUS);
+    std::vector<DelInfo> delInfoVec;
+    GenerateDelInfoToVec(AtmDataType::ACCESSTOKEN_PERMISSION_REQUEST_TOGGLE_STATUS, condition, delInfoVec);
 
-    // delete
-    std::vector<GenericValues> deleteValues;
-    deleteValues.emplace_back(condition);
-
-    // add
-    std::vector<std::vector<GenericValues>> addValues;
-    std::vector<GenericValues> value;
+    std::vector<GenericValues> values;
     condition.Put(TokenFiledConst::FIELD_REQUEST_TOGGLE_STATUS, status);
-    value.emplace_back(condition);
-    addValues.emplace_back(value);
-    int32_t ret = AccessTokenDb::GetInstance().DeleteAndInsertValues(dataTypes, deleteValues, dataTypes, addValues);
+    values.emplace_back(condition);
+
+    std::vector<AddInfo> addInfoVec;
+    GenerateAddInfoToVec(AtmDataType::ACCESSTOKEN_PERMISSION_REQUEST_TOGGLE_STATUS, values, addInfoVec);
+
+    int32_t ret = AccessTokenDb::GetInstance().DeleteAndInsertValues(delInfoVec, addInfoVec);
     if (ret != RET_SUCCESS) {
         LOGE(ATM_DOMAIN, ATM_TAG, "DeleteAndInsertHap failed, ret %{public}d.", ret);
         return ret;
diff --git a/services/accesstokenmanager/test/coverage/permission_manager_coverage_test.cpp b/services/accesstokenmanager/test/coverage/permission_manager_coverage_test.cpp
index eb9b583532a3fc58ecc16aed47ec608fc9fa7569..097e0ec11fb4575a5640532a9114ce1013e8cdeb 100644
--- a/services/accesstokenmanager/test/coverage/permission_manager_coverage_test.cpp
+++ b/services/accesstokenmanager/test/coverage/permission_manager_coverage_test.cpp
@@ -66,11 +66,8 @@ static HapPolicy g_policy = {
 class PermissionManagerCoverageTest : public testing::Test {
 public:
     static void SetUpTestCase();
-
     static void TearDownTestCase();
-
     void SetUp();
-
     void TearDown();
 };
 
@@ -226,7 +223,6 @@ HWTEST_F(PermissionManagerCoverageTest, RestorePermissionPolicy001, TestSize.Lev
     std::vector<BriefPermData> briefPermDataList;
     ASSERT_EQ(RET_SUCCESS, PermissionDataBrief::GetInstance().GetBriefPermDataByTokenId(tokenId, briefPermDataList));
 
-
     GenericValues value2;
     value2.Put(TokenFiledConst::FIELD_TOKEN_ID, RANDOM_TOKENID);
     value2.Put(TokenFiledConst::FIELD_PERMISSION_NAME, "ohos.permission.CAMERA");
@@ -328,44 +324,6 @@ HWTEST_F(PermissionManagerCoverageTest, InitPermissionList001, TestSize.Level4)
     ASSERT_EQ(true, undefValues.empty());
 }
 
-/**
- * @tc.name: FillDelValues001
- * @tc.desc: AccessTokenInfoManager::FillDelValues function test
- * @tc.type: FUNC
- * @tc.require:
- */
-HWTEST_F(PermissionManagerCoverageTest, FillDelValues001, TestSize.Level4)
-{
-    AccessTokenID tokenID = RANDOM_TOKENID;
-    bool isSystemRes = false;
-    std::vector<GenericValues> permExtendValues;
-    std::vector<GenericValues> undefValues;
-    std::vector<GenericValues> deleteValues;
-    AccessTokenInfoManager::GetInstance().FillDelValues(tokenID, isSystemRes, permExtendValues, undefValues,
-        deleteValues);
-    ASSERT_EQ(2, deleteValues.size());
-
-    isSystemRes = true;
-    std::vector<GenericValues> deleteValues2;
-    AccessTokenInfoManager::GetInstance().FillDelValues(tokenID, isSystemRes, permExtendValues, undefValues,
-        deleteValues2);
-    ASSERT_EQ(3, deleteValues2.size());
-
-    GenericValues conditionValue;
-    conditionValue.Put(TokenFiledConst::FIELD_TOKEN_ID, static_cast<int32_t>(tokenID));
-    permExtendValues.emplace_back(conditionValue);
-    std::vector<GenericValues> deleteValues3;
-    AccessTokenInfoManager::GetInstance().FillDelValues(tokenID, isSystemRes, permExtendValues, undefValues,
-        deleteValues3);
-    ASSERT_EQ(4, deleteValues3.size());
-
-    undefValues.emplace_back(conditionValue);
-    std::vector<GenericValues> deleteValues4;
-    AccessTokenInfoManager::GetInstance().FillDelValues(tokenID, isSystemRes, permExtendValues, undefValues,
-        deleteValues4);
-    ASSERT_EQ(5, deleteValues4.size());
-}
-
 /**
  * @tc.name: UpdateUndefinedInfo001
  * @tc.desc: AccessTokenManagerService::UpdateUndefinedInfo function test
@@ -380,7 +338,7 @@ HWTEST_F(PermissionManagerCoverageTest, UpdateUndefinedInfo001, TestSize.Level4)
         undefValues));
     AccessTokenID tokenId = tokenIdEx.tokenIdExStruct.tokenID;
     ASSERT_NE(INVALID_TOKENID, tokenId);
- 
+
     GenericValues value1;
     value1.Put(TokenFiledConst::FIELD_TOKEN_ID, static_cast<int32_t>(tokenId)); // permissionName invalid
     value1.Put(TokenFiledConst::FIELD_PERMISSION_NAME, "ohos.permission.INVALID");
@@ -392,12 +350,12 @@ HWTEST_F(PermissionManagerCoverageTest, UpdateUndefinedInfo001, TestSize.Level4)
     std::vector<GenericValues> validValueList;
     validValueList.emplace_back(value1);
     validValueList.emplace_back(value2);
- 
+
     PermissionDataBrief::GetInstance().DeleteBriefPermDataByTokenId(RANDOM_TOKENID);
     std::shared_ptr<AccessTokenManagerService> atManagerService_ =
         DelayedSingleton<AccessTokenManagerService>::GetInstance();
     ASSERT_NE(nullptr, atManagerService_);
- 
+
     std::vector<GenericValues> stateValues;
     std::vector<GenericValues> extendValues;
     atManagerService_->UpdateUndefinedInfoCache(validValueList, stateValues, extendValues);
@@ -406,7 +364,40 @@ HWTEST_F(PermissionManagerCoverageTest, UpdateUndefinedInfo001, TestSize.Level4)
     ASSERT_EQ(RET_SUCCESS, atManagerService_->DeleteToken(tokenId));
     atManagerService_ = nullptr;
 }
- 
+
+void BackupAndDelOriData(AtmDataType type, std::vector<GenericValues>& oriData)
+{
+    GenericValues conditionValue;
+    // store origin data for backup
+    ASSERT_EQ(RET_SUCCESS, AccessTokenDb::GetInstance().Find(type, conditionValue, oriData));
+
+    DelInfo delInfo;
+    delInfo.delType = type;
+
+    std::vector<DelInfo> delInfoVec;
+    delInfoVec.emplace_back(delInfo);
+    std::vector<AddInfo> addInfoVec;
+    // delete origin data from db
+    ASSERT_EQ(RET_SUCCESS, AccessTokenDb::GetInstance().DeleteAndInsertValues(delInfoVec, addInfoVec));
+}
+
+void DelTestDataAndRestoreOri(AtmDataType type, const std::vector<GenericValues>& oriData)
+{
+    DelInfo delInfo;
+    delInfo.delType = type;
+
+    AddInfo addInfo;
+    addInfo.addType = type;
+    addInfo.addValues = oriData;
+
+    std::vector<DelInfo> delInfoVec;
+    delInfoVec.emplace_back(delInfo);
+    std::vector<AddInfo> addInfoVec;
+    addInfoVec.emplace_back(addInfo);
+    // delete test data and restore origin data from backup
+    ASSERT_EQ(RET_SUCCESS, AccessTokenDb::GetInstance().DeleteAndInsertValues(delInfoVec, addInfoVec));
+}
+
 /**
  * @tc.name: HandleHapUndefinedInfo001
  * @tc.desc: AccessTokenManagerService::HandleHapUndefinedInfo function test
@@ -415,41 +406,23 @@ HWTEST_F(PermissionManagerCoverageTest, UpdateUndefinedInfo001, TestSize.Level4)
  */
 HWTEST_F(PermissionManagerCoverageTest, HandleHapUndefinedInfo001, TestSize.Level4)
 {
-    GenericValues conditionValue;
-    std::vector<GenericValues> results;
-    ASSERT_EQ(RET_SUCCESS, AccessTokenDb::GetInstance().Find(
-        AtmDataType::ACCESSTOKEN_HAP_UNDEFINE_INFO, conditionValue, results)); // store origin data
- 
-    GenericValues value;
-    std::vector<AtmDataType> deleteDataTypes;
-    std::vector<GenericValues> deleteValues;
-    deleteDataTypes.emplace_back(AtmDataType::ACCESSTOKEN_HAP_UNDEFINE_INFO);
-    deleteValues.emplace_back(value);
-    std::vector<AtmDataType> addDataTypes;
-    std::vector<std::vector<GenericValues>> addValues;
-    ASSERT_EQ(RET_SUCCESS, AccessTokenDb::GetInstance().DeleteAndInsertValues(
-        deleteDataTypes, deleteValues, addDataTypes, addValues)); // delete all data
- 
+    AtmDataType type = AtmDataType::ACCESSTOKEN_HAP_UNDEFINE_INFO;
+    std::vector<GenericValues> oriData;
+    BackupAndDelOriData(type, oriData);
+
     std::shared_ptr<AccessTokenManagerService> atManagerService_ =
         DelayedSingleton<AccessTokenManagerService>::GetInstance();
     EXPECT_NE(nullptr, atManagerService_);
- 
+
     std::map<int32_t, int32_t> tokenIdAplMap;
-    std::vector<AtmDataType> deleteDataTypes2;
-    std::vector<GenericValues> deleteValues2;
-    std::vector<AtmDataType> addDataTypes2;
-    std::vector<std::vector<GenericValues>> addValues2;
-    atManagerService_->HandleHapUndefinedInfo(tokenIdAplMap, deleteDataTypes2, deleteValues2, addDataTypes2,
-        addValues2);
- 
-    addDataTypes.emplace_back(AtmDataType::ACCESSTOKEN_HAP_UNDEFINE_INFO);
-    addValues.emplace_back(results);
-    ASSERT_EQ(RET_SUCCESS, AccessTokenDb::GetInstance().DeleteAndInsertValues(
-        deleteDataTypes, deleteValues, addDataTypes, addValues)); // sotre origin data
- 
+    std::vector<DelInfo> delInfoVec;
+    std::vector<AddInfo> addInfoVec;
+    atManagerService_->HandleHapUndefinedInfo(tokenIdAplMap, delInfoVec, addInfoVec);
+
+    DelTestDataAndRestoreOri(type, oriData);
     atManagerService_ = nullptr;
 }
- 
+
 /**
  * @tc.name: HandleHapUndefinedInfo002
  * @tc.desc: AccessTokenManagerService::HandleHapUndefinedInfo function test
@@ -458,53 +431,37 @@ HWTEST_F(PermissionManagerCoverageTest, HandleHapUndefinedInfo001, TestSize.Leve
  */
 HWTEST_F(PermissionManagerCoverageTest, HandleHapUndefinedInfo002, TestSize.Level4)
 {
-    GenericValues conditionValue;
-    std::vector<GenericValues> results;
-    ASSERT_EQ(RET_SUCCESS, AccessTokenDb::GetInstance().Find(
-        AtmDataType::ACCESSTOKEN_HAP_UNDEFINE_INFO, conditionValue, results)); // store origin data
- 
-    GenericValues delValue;
-    std::vector<AtmDataType> deleteDataTypes;
-    std::vector<GenericValues> deleteValues;
-    deleteDataTypes.emplace_back(AtmDataType::ACCESSTOKEN_HAP_UNDEFINE_INFO);
-    deleteValues.emplace_back(delValue);
-    std::vector<AtmDataType> addDataTypes;
-    std::vector<std::vector<GenericValues>> addValues;
-    ASSERT_EQ(RET_SUCCESS, AccessTokenDb::GetInstance().DeleteAndInsertValues(
-        deleteDataTypes, deleteValues, addDataTypes, addValues)); // delete all data
- 
+    AtmDataType type = AtmDataType::ACCESSTOKEN_HAP_UNDEFINE_INFO;
+    std::vector<GenericValues> oriData;
+    BackupAndDelOriData(type, oriData);
+
     GenericValues value;
     value.Put(TokenFiledConst::FIELD_TOKEN_ID, RANDOM_TOKENID);
     value.Put(TokenFiledConst::FIELD_PERMISSION_NAME, "ohos.permission.SET_ENTERPRISE_INFO"); // mdm permission
     value.Put(TokenFiledConst::FIELD_ACL, 0);
     value.Put(TokenFiledConst::FIELD_APP_DISTRIBUTION_TYPE, "os_integration");
-    std::vector<GenericValues> values;
-    values.emplace_back(value);
- 
-    addDataTypes.emplace_back(AtmDataType::ACCESSTOKEN_HAP_UNDEFINE_INFO);
-    addValues.emplace_back(values);
-    EXPECT_EQ(RET_SUCCESS, AccessTokenDb::GetInstance().DeleteAndInsertValues(
-        deleteDataTypes, deleteValues, addDataTypes, addValues)); // add test data
-    addValues.clear();
- 
+    AddInfo addInfo;
+    addInfo.addType = type;
+    addInfo.addValues.emplace_back(value);
+
+    std::vector<DelInfo> delInfoVec;
+    std::vector<AddInfo> addInfoVec;
+    addInfoVec.emplace_back(addInfo);
+    EXPECT_EQ(RET_SUCCESS, AccessTokenDb::GetInstance().DeleteAndInsertValues(delInfoVec, addInfoVec)); // add test data
+
     std::shared_ptr<AccessTokenManagerService> atManagerService_ =
         DelayedSingleton<AccessTokenManagerService>::GetInstance();
     EXPECT_NE(nullptr, atManagerService_);
- 
+
     std::map<int32_t, int32_t> tokenIdAplMap;
-    std::vector<AtmDataType> deleteDataTypes2;
-    std::vector<GenericValues> deleteValues2;
-    std::vector<AtmDataType> addDataTypes2;
-    std::vector<std::vector<GenericValues>> addValues2;
-    atManagerService_->HandleHapUndefinedInfo(tokenIdAplMap, deleteDataTypes2, deleteValues2, addDataTypes2,
-        addValues2);
- 
-    addValues.emplace_back(results);
-    ASSERT_EQ(RET_SUCCESS, AccessTokenDb::GetInstance().DeleteAndInsertValues(
-        deleteDataTypes, deleteValues, addDataTypes, addValues)); // sotre origin data
+    std::vector<DelInfo> delInfoVec2;
+    std::vector<AddInfo> addInfoVec2;
+    atManagerService_->HandleHapUndefinedInfo(tokenIdAplMap, delInfoVec2, addInfoVec2);
+
+    DelTestDataAndRestoreOri(type, oriData);
     atManagerService_ = nullptr;
 }
- 
+
 /**
  * @tc.name: HandlePermDefUpdate001
  * @tc.desc: AccessTokenManagerService::HandlePermDefUpdate function test
@@ -513,36 +470,21 @@ HWTEST_F(PermissionManagerCoverageTest, HandleHapUndefinedInfo002, TestSize.Leve
  */
 HWTEST_F(PermissionManagerCoverageTest, HandlePermDefUpdate001, TestSize.Level4)
 {
-    GenericValues conditionValue;
-    std::vector<GenericValues> results;
-    ASSERT_EQ(RET_SUCCESS, AccessTokenDb::GetInstance().Find(
-        AtmDataType::ACCESSTOKEN_SYSTEM_CONFIG, conditionValue, results)); // store origin data
- 
-    GenericValues value;
-    std::vector<AtmDataType> deleteDataTypes;
-    std::vector<GenericValues> deleteValues;
-    deleteDataTypes.emplace_back(AtmDataType::ACCESSTOKEN_SYSTEM_CONFIG);
-    deleteValues.emplace_back(value);
-    std::vector<AtmDataType> addDataTypes;
-    std::vector<std::vector<GenericValues>> addValues;
-    ASSERT_EQ(RET_SUCCESS, AccessTokenDb::GetInstance().DeleteAndInsertValues(
-        deleteDataTypes, deleteValues, addDataTypes, addValues)); // delete all data
- 
+    AtmDataType type = AtmDataType::ACCESSTOKEN_SYSTEM_CONFIG;
+    std::vector<GenericValues> oriData;
+    BackupAndDelOriData(type, oriData);
+
     std::shared_ptr<AccessTokenManagerService> atManagerService_ =
         DelayedSingleton<AccessTokenManagerService>::GetInstance();
     EXPECT_NE(nullptr, atManagerService_);
- 
+
     std::map<int32_t, int32_t> tokenIdAplMap;
     atManagerService_->HandlePermDefUpdate(tokenIdAplMap); // dbPermDefVersion is empty
- 
-    addDataTypes.emplace_back(AtmDataType::ACCESSTOKEN_SYSTEM_CONFIG);
-    addValues.emplace_back(results);
-    ASSERT_EQ(RET_SUCCESS, AccessTokenDb::GetInstance().DeleteAndInsertValues(
-        deleteDataTypes, deleteValues, addDataTypes, addValues)); // sotre origin data
- 
+
+    DelTestDataAndRestoreOri(type, oriData);
     atManagerService_ = nullptr;
 }
- 
+
 /**
  * @tc.name: HandlePermDefUpdate002
  * @tc.desc: AccessTokenManagerService::HandlePermDefUpdate function test
@@ -551,41 +493,31 @@ HWTEST_F(PermissionManagerCoverageTest, HandlePermDefUpdate001, TestSize.Level4)
  */
 HWTEST_F(PermissionManagerCoverageTest, HandlePermDefUpdate002, TestSize.Level4)
 {
-    GenericValues conditionValue;
-    std::vector<GenericValues> results;
-    ASSERT_EQ(RET_SUCCESS, AccessTokenDb::GetInstance().Find(
-        AtmDataType::ACCESSTOKEN_SYSTEM_CONFIG, conditionValue, results)); // store origin data
- 
-    GenericValues value;
+    AtmDataType type = AtmDataType::ACCESSTOKEN_SYSTEM_CONFIG;
+    std::vector<GenericValues> oriData;
+    BackupAndDelOriData(type, oriData);
+
     GenericValues addValue;
     addValue.Put(TokenFiledConst::FIELD_NAME, PERM_DEF_VERSION);
     addValue.Put(TokenFiledConst::FIELD_VALUE, "sfdsfdsfsf"); // random input
-    std::vector<GenericValues> values;
-    values.emplace_back(addValue);
- 
-    std::vector<AtmDataType> deleteDataTypes;
-    std::vector<GenericValues> deleteValues;
-    deleteDataTypes.emplace_back(AtmDataType::ACCESSTOKEN_SYSTEM_CONFIG);
-    deleteValues.emplace_back(value);
-    std::vector<AtmDataType> addDataTypes;
-    std::vector<std::vector<GenericValues>> addValues;
-    addDataTypes.emplace_back(AtmDataType::ACCESSTOKEN_SYSTEM_CONFIG);
-    addValues.emplace_back(values);
-    ASSERT_EQ(RET_SUCCESS, AccessTokenDb::GetInstance().DeleteAndInsertValues(
-        deleteDataTypes, deleteValues, addDataTypes, addValues)); // update permission define version in db
-    addValues.clear();
- 
+    AddInfo addInfo;
+    addInfo.addType = type;
+    addInfo.addValues.emplace_back(addValue);
+
+    std::vector<DelInfo> delInfoVec;
+    std::vector<AddInfo> addInfoVec;
+    addInfoVec.emplace_back(addInfo);
+    // update permission define version in db to test data
+    EXPECT_EQ(RET_SUCCESS, AccessTokenDb::GetInstance().DeleteAndInsertValues(delInfoVec, addInfoVec));
+
     std::shared_ptr<AccessTokenManagerService> atManagerService_ =
         DelayedSingleton<AccessTokenManagerService>::GetInstance();
     EXPECT_NE(nullptr, atManagerService_);
- 
+
     std::map<int32_t, int32_t> tokenIdAplMap;
     atManagerService_->HandlePermDefUpdate(tokenIdAplMap); // dbPermDefVersion is not empty
- 
-    addValues.emplace_back(results);
-    ASSERT_EQ(RET_SUCCESS, AccessTokenDb::GetInstance().DeleteAndInsertValues(
-        deleteDataTypes, deleteValues, addDataTypes, addValues)); // sotre origin data
- 
+
+    DelTestDataAndRestoreOri(type, oriData);
     atManagerService_ = nullptr;
 }
 } // namespace AccessToken
diff --git a/services/accesstokenmanager/test/unittest/accesstoken_manager_service_test.cpp b/services/accesstokenmanager/test/unittest/accesstoken_manager_service_test.cpp
index 77010240f0806295e22020072477eb6d346e9a67..bf24287d4860184e088f511d47e804e76ae4fa29 100644
--- a/services/accesstokenmanager/test/unittest/accesstoken_manager_service_test.cpp
+++ b/services/accesstokenmanager/test/unittest/accesstoken_manager_service_test.cpp
@@ -399,6 +399,43 @@ HWTEST_F(AccessTokenManagerServiceTest, UpdateHapTokenTest003, TestSize.Level0)
     ASSERT_EQ(0, atManagerService_->DeleteToken(tokenId));
 }
 
+void BackupAndDelOriData(std::vector<GenericValues>& oriData)
+{
+    GenericValues conditionValue;
+    // store origin data for backup
+    ASSERT_EQ(RET_SUCCESS, AccessTokenDb::GetInstance().Find(AtmDataType::ACCESSTOKEN_HAP_UNDEFINE_INFO, conditionValue,
+        oriData));
+
+    DelInfo delInfo;
+    delInfo.delType = AtmDataType::ACCESSTOKEN_HAP_UNDEFINE_INFO;
+
+    std::vector<DelInfo> delInfoVec;
+    delInfoVec.emplace_back(delInfo);
+    std::vector<AddInfo> addInfoVec;
+    // delete origin data from db
+    ASSERT_EQ(RET_SUCCESS, AccessTokenDb::GetInstance().DeleteAndInsertValues(delInfoVec, addInfoVec));
+}
+
+void AccessTokenManagerServiceTest::DelTestDataAndRestoreOri(AccessTokenID tokenId,
+    const std::vector<GenericValues>& oriData)
+{
+    EXPECT_EQ(0, atManagerService_->DeleteToken(tokenId));
+
+    DelInfo delInfo;
+    delInfo.delType = AtmDataType::ACCESSTOKEN_HAP_UNDEFINE_INFO;
+
+    AddInfo addInfo;
+    addInfo.addType = AtmDataType::ACCESSTOKEN_HAP_UNDEFINE_INFO;
+    addInfo.addValues = oriData;
+
+    std::vector<DelInfo> delInfoVec;
+    delInfoVec.emplace_back(delInfo);
+    std::vector<AddInfo> addInfoVec;
+    addInfoVec.emplace_back(addInfo);
+    // delete test data and restore origin data from backup
+    ASSERT_EQ(RET_SUCCESS, AccessTokenDb::GetInstance().DeleteAndInsertValues(delInfoVec, addInfoVec));
+}
+
 /**
  * @tc.name: OTATest001
  * @tc.desc: test after ota invalid tokenId remain
@@ -407,6 +444,10 @@ HWTEST_F(AccessTokenManagerServiceTest, UpdateHapTokenTest003, TestSize.Level0)
  */
 HWTEST_F(AccessTokenManagerServiceTest, OTATest001, TestSize.Level0)
 {
+    AtmDataType type = AtmDataType::ACCESSTOKEN_HAP_UNDEFINE_INFO;
+    std::vector<GenericValues> oriData;
+    BackupAndDelOriData(oriData);
+
     HapInfoParcel infoParCel;
     infoParCel.hapInfoParameter = g_info;
     HapPolicyParcel policyParcel;
@@ -421,45 +462,27 @@ HWTEST_F(AccessTokenManagerServiceTest, OTATest001, TestSize.Level0)
     value.Put(TokenFiledConst::FIELD_TOKEN_ID, RANDOM_TOKENID);
     value.Put(TokenFiledConst::FIELD_PERMISSION_NAME, g_state2.permissionName); // INVALIDA
     value.Put(TokenFiledConst::FIELD_ACL, 0);
-    std::vector<GenericValues> values;
-    values.emplace_back(value);
+    AddInfo addInfo;
+    addInfo.addType = type;
+    addInfo.addValues.emplace_back(value);
 
-    std::vector<AtmDataType> deleteDataTypes;
-    std::vector<GenericValues> deleteValues;
-    std::vector<AtmDataType> addDataTypes;
-    addDataTypes.emplace_back(AtmDataType::ACCESSTOKEN_HAP_UNDEFINE_INFO);
-    std::vector<std::vector<GenericValues>> addValues;
-    addValues.emplace_back(values);
-    ASSERT_EQ(0, AccessTokenDb::GetInstance().DeleteAndInsertValues(
-        deleteDataTypes, deleteValues, addDataTypes, addValues));
-
-    std::vector<AtmDataType> deleteDataTypes2;
-    std::vector<GenericValues> deleteValues2;
-    std::vector<AtmDataType> addDataTypes2;
-    std::vector<std::vector<GenericValues>> addValues2;
-    atManagerService_->HandleHapUndefinedInfo(tokenIdAplMap, deleteDataTypes2, deleteValues2, addDataTypes2,
-        addValues2);
-    ASSERT_EQ(0, AccessTokenDb::GetInstance().DeleteAndInsertValues(deleteDataTypes2, deleteValues2, addDataTypes2,
-        addValues2));
+    std::vector<DelInfo> delInfoVec;
+    std::vector<AddInfo> addInfoVec;
+    addInfoVec.emplace_back(addInfo);
+    EXPECT_EQ(0, AccessTokenDb::GetInstance().DeleteAndInsertValues(delInfoVec, addInfoVec)); // add test data
+
+    std::vector<DelInfo> delInfoVec2;
+    std::vector<AddInfo> addInfoVec2;
+    atManagerService_->HandleHapUndefinedInfo(tokenIdAplMap, delInfoVec2, addInfoVec2);
+    EXPECT_EQ(0, AccessTokenDb::GetInstance().DeleteAndInsertValues(delInfoVec2, addInfoVec2));
 
     GenericValues conditionValue;
     conditionValue.Put(TokenFiledConst::FIELD_TOKEN_ID, RANDOM_TOKENID);
     std::vector<GenericValues> results;
-    ASSERT_EQ(0, AccessTokenDb::GetInstance().Find(
-        AtmDataType::ACCESSTOKEN_HAP_UNDEFINE_INFO, conditionValue, results));
-    ASSERT_EQ(false, results.empty()); // undefine table is not empty
-
-    GenericValues delValue; // system grant
-    delValue.Put(TokenFiledConst::FIELD_TOKEN_ID, RANDOM_TOKENID);
-    std::vector<AtmDataType> deleteDataTypes3;
-    deleteDataTypes2.emplace_back(AtmDataType::ACCESSTOKEN_HAP_UNDEFINE_INFO);
-    std::vector<GenericValues> deleteValues3;
-    deleteValues2.emplace_back(delValue);
-    std::vector<AtmDataType> addDataTypes3;
-    std::vector<std::vector<GenericValues>> addValues3;
-    ASSERT_EQ(0, AccessTokenDb::GetInstance().DeleteAndInsertValues(
-        deleteDataTypes3, deleteValues3, addDataTypes3, addValues3));
-    ASSERT_EQ(0, atManagerService_->DeleteToken(tokenId));
+    EXPECT_EQ(0, AccessTokenDb::GetInstance().Find(type, conditionValue, results));
+    EXPECT_EQ(false, results.empty()); // undefine table is not empty
+
+    DelTestDataAndRestoreOri(tokenId, oriData);
 }
 
 /**
@@ -470,6 +493,10 @@ HWTEST_F(AccessTokenManagerServiceTest, OTATest001, TestSize.Level0)
  */
 HWTEST_F(AccessTokenManagerServiceTest, OTATest002, TestSize.Level0)
 {
+    AtmDataType type = AtmDataType::ACCESSTOKEN_HAP_UNDEFINE_INFO;
+    std::vector<GenericValues> oriData;
+    BackupAndDelOriData(oriData);
+
     HapInfoParcel infoParCel;
     infoParCel.hapInfoParameter = g_info;
     HapPolicyParcel policyParcel;
@@ -484,47 +511,39 @@ HWTEST_F(AccessTokenManagerServiceTest, OTATest002, TestSize.Level0)
     value.Put(TokenFiledConst::FIELD_TOKEN_ID, static_cast<int32_t>(tokenId));
     value.Put(TokenFiledConst::FIELD_PERMISSION_NAME, g_state2.permissionName); // INVALIDA
     value.Put(TokenFiledConst::FIELD_ACL, 0);
-    std::vector<GenericValues> values;
-    values.emplace_back(value);
+    AddInfo addInfo;
+    addInfo.addType = type;
+    addInfo.addValues.emplace_back(value);
+
+    std::vector<DelInfo> delInfoVec;
+    std::vector<AddInfo> addInfoVec;
+    addInfoVec.emplace_back(addInfo);
+    EXPECT_EQ(0, AccessTokenDb::GetInstance().DeleteAndInsertValues(delInfoVec, addInfoVec)); // add test data
 
-    std::vector<AtmDataType> deleteDataTypes;
-    std::vector<GenericValues> deleteValues;
-    std::vector<AtmDataType> addDataTypes;
-    addDataTypes.emplace_back(AtmDataType::ACCESSTOKEN_HAP_UNDEFINE_INFO);
-    std::vector<std::vector<GenericValues>> addValues;
-    addValues.emplace_back(values);
-    ASSERT_EQ(0, AccessTokenDb::GetInstance().DeleteAndInsertValues(
-        deleteDataTypes, deleteValues, addDataTypes, addValues));
-
-    std::vector<AtmDataType> deleteDataTypes2;
-    std::vector<GenericValues> deleteValues2;
-    std::vector<AtmDataType> addDataTypes2;
-    std::vector<std::vector<GenericValues>> addValues2;
-    atManagerService_->HandleHapUndefinedInfo(tokenIdAplMap, deleteDataTypes2, deleteValues2, addDataTypes2,
-        addValues2);
-    ASSERT_EQ(0, AccessTokenDb::GetInstance().DeleteAndInsertValues(deleteDataTypes2, deleteValues2, addDataTypes2,
-        addValues2));
+    std::vector<DelInfo> delInfoVec2;
+    std::vector<AddInfo> addInfoVec2;
+    atManagerService_->HandleHapUndefinedInfo(tokenIdAplMap, delInfoVec2, addInfoVec2);
+    EXPECT_EQ(0, AccessTokenDb::GetInstance().DeleteAndInsertValues(delInfoVec2, addInfoVec2));
 
     GenericValues conditionValue;
     conditionValue.Put(TokenFiledConst::FIELD_TOKEN_ID, static_cast<int32_t>(tokenId));
     std::vector<GenericValues> results;
-    ASSERT_EQ(0, AccessTokenDb::GetInstance().Find(
-        AtmDataType::ACCESSTOKEN_HAP_UNDEFINE_INFO, conditionValue, results));
-    ASSERT_EQ(false, results.empty()); // undefine table is not empty
+    EXPECT_EQ(0, AccessTokenDb::GetInstance().Find(type, conditionValue, results));
+    EXPECT_EQ(false, results.empty()); // undefine table is not empty
 
     std::vector<GenericValues> results2;
-    ASSERT_EQ(0, AccessTokenDb::GetInstance().Find(
+    EXPECT_EQ(0, AccessTokenDb::GetInstance().Find(
         AtmDataType::ACCESSTOKEN_PERMISSION_STATE, conditionValue, results2));
     for (const auto& value : results2) {
-        ASSERT_NE(value.GetString(TokenFiledConst::FIELD_PERMISSION_NAME), g_state2.permissionName);
+        EXPECT_NE(value.GetString(TokenFiledConst::FIELD_PERMISSION_NAME), g_state2.permissionName);
     }
 
     std::vector<GenericValues> results3;
-    ASSERT_EQ(0, AccessTokenDb::GetInstance().Find(
+    EXPECT_EQ(0, AccessTokenDb::GetInstance().Find(
         AtmDataType::ACCESSTOKEN_PERMISSION_EXTEND_VALUE, conditionValue, results3));
-    ASSERT_EQ(true, results3.empty()); // extend table is empty
+    EXPECT_EQ(true, results3.empty()); // extend table is empty
 
-    ASSERT_EQ(0, atManagerService_->DeleteToken(tokenId));
+    DelTestDataAndRestoreOri(tokenId, oriData);
 }
 
 void SetValues003(AccessTokenID tokenId, std::vector<GenericValues>& values)
@@ -539,7 +558,7 @@ void SetValues003(AccessTokenID tokenId, std::vector<GenericValues>& values)
     value2.Put(TokenFiledConst::FIELD_ACL, 0);
     values.emplace_back(value1);
     values.emplace_back(value2);
-}
+} 
 
 /**
  * @tc.name: OTATest003
@@ -549,6 +568,10 @@ void SetValues003(AccessTokenID tokenId, std::vector<GenericValues>& values)
  */
 HWTEST_F(AccessTokenManagerServiceTest, OTATest003, TestSize.Level0)
 {
+    AtmDataType type = AtmDataType::ACCESSTOKEN_HAP_UNDEFINE_INFO;
+    std::vector<GenericValues> oriData;
+    BackupAndDelOriData(oriData);
+
     HapInfoParcel infoParCel;
     infoParCel.hapInfoParameter = g_info;
     HapPolicyParcel policyParcel;
@@ -560,48 +583,41 @@ HWTEST_F(AccessTokenManagerServiceTest, OTATest003, TestSize.Level0)
 
     std::vector<GenericValues> values;
     SetValues003(tokenId, values);
+    AddInfo addInfo;
+    addInfo.addType = type;
+    addInfo.addValues = values;
+
+    std::vector<DelInfo> delInfoVec;
+    std::vector<AddInfo> addInfoVec;
+    addInfoVec.emplace_back(addInfo);
+    EXPECT_EQ(0, AccessTokenDb::GetInstance().DeleteAndInsertValues(delInfoVec, addInfoVec)); // add test data
 
-    std::vector<AtmDataType> deleteDataTypes;
-    std::vector<GenericValues> deleteValues;
-    std::vector<AtmDataType> addDataTypes;
-    addDataTypes.emplace_back(AtmDataType::ACCESSTOKEN_HAP_UNDEFINE_INFO);
-    std::vector<std::vector<GenericValues>> addValues;
-    addValues.emplace_back(values);
-    ASSERT_EQ(0, AccessTokenDb::GetInstance().DeleteAndInsertValues(
-        deleteDataTypes, deleteValues, addDataTypes, addValues));
-
-    std::vector<AtmDataType> deleteDataTypes2;
-    std::vector<GenericValues> deleteValues2;
-    std::vector<AtmDataType> addDataTypes2;
-    std::vector<std::vector<GenericValues>> addValues2;
-    atManagerService_->HandleHapUndefinedInfo(tokenIdAplMap, deleteDataTypes2, deleteValues2, addDataTypes2,
-        addValues2);
-    ASSERT_EQ(0, AccessTokenDb::GetInstance().DeleteAndInsertValues(deleteDataTypes2, deleteValues2, addDataTypes2,
-        addValues2));
+    std::vector<DelInfo> delInfoVec2;
+    std::vector<AddInfo> addInfoVec2;
+    atManagerService_->HandleHapUndefinedInfo(tokenIdAplMap, delInfoVec2, addInfoVec2);
+    EXPECT_EQ(0, AccessTokenDb::GetInstance().DeleteAndInsertValues(delInfoVec2, addInfoVec2));
 
     GenericValues conditionValue;
     conditionValue.Put(TokenFiledConst::FIELD_TOKEN_ID, static_cast<int32_t>(tokenId));
     std::vector<GenericValues> results;
-    ASSERT_EQ(0, AccessTokenDb::GetInstance().Find(
-        AtmDataType::ACCESSTOKEN_HAP_UNDEFINE_INFO, conditionValue, results));
-    ASSERT_EQ(true, results.empty()); // undefine table is empty
+    EXPECT_EQ(0, AccessTokenDb::GetInstance().Find(type, conditionValue, results));
+    EXPECT_EQ(true, results.empty()); // undefine table is empty
 
-    ASSERT_EQ(0, AccessTokenDb::GetInstance().Find(
-        AtmDataType::ACCESSTOKEN_PERMISSION_STATE, conditionValue, results));
+    EXPECT_EQ(0, AccessTokenDb::GetInstance().Find(AtmDataType::ACCESSTOKEN_PERMISSION_STATE, conditionValue, results));
 
     for (const auto& value : results) {
         int32_t state = value.GetInt(TokenFiledConst::FIELD_GRANT_STATE);
         int32_t flag = value.GetInt(TokenFiledConst::FIELD_GRANT_FLAG);
         if (value.GetString(TokenFiledConst::FIELD_PERMISSION_NAME) == g_state4.permissionName) { // user grant
-            ASSERT_EQ(state, static_cast<int32_t>(PermissionState::PERMISSION_DENIED)); // state: 0 -> -1
-            ASSERT_EQ(flag, static_cast<int32_t>(PermissionFlag::PERMISSION_DEFAULT_FLAG)); // flag: 4 -> 0
+            EXPECT_EQ(state, static_cast<int32_t>(PermissionState::PERMISSION_DENIED)); // state: 0 -> -1
+            EXPECT_EQ(flag, static_cast<int32_t>(PermissionFlag::PERMISSION_DEFAULT_FLAG)); // flag: 4 -> 0
         } else if (value.GetString(TokenFiledConst::FIELD_PERMISSION_NAME) == g_state5.permissionName) { // system grant
-            ASSERT_EQ(state, static_cast<int32_t>(PermissionState::PERMISSION_GRANTED)); // state: -1 -> 0
-            ASSERT_EQ(flag, static_cast<int32_t>(PermissionFlag::PERMISSION_SYSTEM_FIXED)); // flag: 0 -> 4
+            EXPECT_EQ(state, static_cast<int32_t>(PermissionState::PERMISSION_GRANTED)); // state: -1 -> 0
+            EXPECT_EQ(flag, static_cast<int32_t>(PermissionFlag::PERMISSION_SYSTEM_FIXED)); // flag: 0 -> 4
         }
     }
 
-    ASSERT_EQ(0, atManagerService_->DeleteToken(tokenId));
+    DelTestDataAndRestoreOri(tokenId, oriData);
 }
 
 /**
@@ -612,6 +628,10 @@ HWTEST_F(AccessTokenManagerServiceTest, OTATest003, TestSize.Level0)
  */
 HWTEST_F(AccessTokenManagerServiceTest, OTATest004, TestSize.Level0)
 {
+    AtmDataType type = AtmDataType::ACCESSTOKEN_HAP_UNDEFINE_INFO;
+    std::vector<GenericValues> oriData;
+    BackupAndDelOriData(oriData);
+
     HapInfoParcel infoParCel;
     infoParCel.hapInfoParameter = g_info;
     HapPolicyParcel policyParcel;
@@ -625,42 +645,34 @@ HWTEST_F(AccessTokenManagerServiceTest, OTATest004, TestSize.Level0)
     value.Put(TokenFiledConst::FIELD_TOKEN_ID, static_cast<int32_t>(tokenId));
     value.Put(TokenFiledConst::FIELD_PERMISSION_NAME, g_state6.permissionName);
     value.Put(TokenFiledConst::FIELD_ACL, 0); // system core permission without acl
-    std::vector<GenericValues> values;
-    values.emplace_back(value);
+    AddInfo addInfo;
+    addInfo.addType = type;
+    addInfo.addValues.emplace_back(value);
 
-    std::vector<AtmDataType> deleteDataTypes;
-    std::vector<GenericValues> deleteValues;
-    std::vector<AtmDataType> addDataTypes;
-    addDataTypes.emplace_back(AtmDataType::ACCESSTOKEN_HAP_UNDEFINE_INFO);
-    std::vector<std::vector<GenericValues>> addValues;
-    addValues.emplace_back(values);
-    ASSERT_EQ(0, AccessTokenDb::GetInstance().DeleteAndInsertValues(
-        deleteDataTypes, deleteValues, addDataTypes, addValues));
-
-    std::vector<AtmDataType> deleteDataTypes2;
-    std::vector<GenericValues> deleteValues2;
-    std::vector<AtmDataType> addDataTypes2;
-    std::vector<std::vector<GenericValues>> addValues2;
-    atManagerService_->HandleHapUndefinedInfo(tokenIdAplMap, deleteDataTypes2, deleteValues2, addDataTypes2,
-        addValues2);
-    ASSERT_EQ(0, AccessTokenDb::GetInstance().DeleteAndInsertValues(deleteDataTypes2, deleteValues2, addDataTypes2,
-        addValues2));
+    std::vector<DelInfo> delInfoVec;
+    std::vector<AddInfo> addInfoVec;
+    addInfoVec.emplace_back(addInfo);
+    EXPECT_EQ(0, AccessTokenDb::GetInstance().DeleteAndInsertValues(delInfoVec, addInfoVec)); // add test data
+
+    std::vector<DelInfo> delInfoVec2;
+    std::vector<AddInfo> addInfoVec2;
+    atManagerService_->HandleHapUndefinedInfo(tokenIdAplMap, delInfoVec2, addInfoVec2);
+    EXPECT_EQ(0, AccessTokenDb::GetInstance().DeleteAndInsertValues(delInfoVec2, addInfoVec2));
 
     GenericValues conditionValue;
     conditionValue.Put(TokenFiledConst::FIELD_TOKEN_ID, static_cast<int32_t>(tokenId));
     std::vector<GenericValues> results;
-    ASSERT_EQ(0, AccessTokenDb::GetInstance().Find(
-        AtmDataType::ACCESSTOKEN_HAP_UNDEFINE_INFO, conditionValue, results));
-    ASSERT_EQ(false, results.empty()); // undefine table not empty
+    EXPECT_EQ(0, AccessTokenDb::GetInstance().Find(type, conditionValue, results));
+    EXPECT_EQ(false, results.empty()); // undefine table not empty
 
     std::vector<GenericValues> results2;
-    ASSERT_EQ(0, AccessTokenDb::GetInstance().Find(
+    EXPECT_EQ(0, AccessTokenDb::GetInstance().Find(
         AtmDataType::ACCESSTOKEN_PERMISSION_STATE, conditionValue, results2));
     for (const auto& value : results2) {
-        ASSERT_NE(value.GetString(TokenFiledConst::FIELD_PERMISSION_NAME), g_state6.permissionName);
+        EXPECT_NE(value.GetString(TokenFiledConst::FIELD_PERMISSION_NAME), g_state6.permissionName);
     }
 
-    ASSERT_EQ(0, atManagerService_->DeleteToken(tokenId));
+    DelTestDataAndRestoreOri(tokenId, oriData);
 }
 
 /**
@@ -671,6 +683,10 @@ HWTEST_F(AccessTokenManagerServiceTest, OTATest004, TestSize.Level0)
  */
 HWTEST_F(AccessTokenManagerServiceTest, OTATest005, TestSize.Level0)
 {
+    AtmDataType type = AtmDataType::ACCESSTOKEN_HAP_UNDEFINE_INFO;
+    std::vector<GenericValues> oriData;
+    BackupAndDelOriData(oriData);
+
     HapInfoParcel infoParCel;
     infoParCel.hapInfoParameter = g_info;
     HapPolicyParcel policyParcel;
@@ -685,44 +701,38 @@ HWTEST_F(AccessTokenManagerServiceTest, OTATest005, TestSize.Level0)
     value.Put(TokenFiledConst::FIELD_TOKEN_ID, static_cast<int32_t>(tokenId));
     value.Put(TokenFiledConst::FIELD_PERMISSION_NAME, g_state6.permissionName);
     value.Put(TokenFiledConst::FIELD_ACL, 1); // system core permission with acl
-    std::vector<GenericValues> values;
-    values.emplace_back(value);
+    AddInfo addInfo;
+    addInfo.addType = type;
+    addInfo.addValues.emplace_back(value);
+
+    std::vector<DelInfo> delInfoVec;
+    std::vector<AddInfo> addInfoVec;
+    addInfoVec.emplace_back(addInfo);
+    EXPECT_EQ(0, AccessTokenDb::GetInstance().DeleteAndInsertValues(delInfoVec, addInfoVec)); // add test data
 
-    std::vector<AtmDataType> deleteDataTypes;
-    std::vector<GenericValues> deleteValues;
-    std::vector<AtmDataType> addDataTypes;
-    addDataTypes.emplace_back(AtmDataType::ACCESSTOKEN_HAP_UNDEFINE_INFO);
-    std::vector<std::vector<GenericValues>> addValues;
-    addValues.emplace_back(values);
-    ASSERT_EQ(0, AccessTokenDb::GetInstance().DeleteAndInsertValues(
-        deleteDataTypes, deleteValues, addDataTypes, addValues));
-
-    addDataTypes.clear();
-    addValues.clear();
-    atManagerService_->HandleHapUndefinedInfo(tokenIdAplMap, deleteDataTypes, deleteValues, addDataTypes, addValues);
-    ASSERT_EQ(0, AccessTokenDb::GetInstance().DeleteAndInsertValues(deleteDataTypes, deleteValues, addDataTypes,
-        addValues));
+    std::vector<DelInfo> delInfoVec2;
+    std::vector<AddInfo> addInfoVec2;
+    atManagerService_->HandleHapUndefinedInfo(tokenIdAplMap, delInfoVec2, addInfoVec2);
+    EXPECT_EQ(0, AccessTokenDb::GetInstance().DeleteAndInsertValues(delInfoVec2, addInfoVec2));
 
     GenericValues conditionValue;
     conditionValue.Put(TokenFiledConst::FIELD_TOKEN_ID, static_cast<int32_t>(tokenId));
     std::vector<GenericValues> results;
-    ASSERT_EQ(0, AccessTokenDb::GetInstance().Find(
-        AtmDataType::ACCESSTOKEN_HAP_UNDEFINE_INFO, conditionValue, results));
-    ASSERT_EQ(true, results.empty()); // undefine table is empty
+    EXPECT_EQ(0, AccessTokenDb::GetInstance().Find(type, conditionValue, results));
+    EXPECT_EQ(true, results.empty()); // undefine table is empty
 
-    ASSERT_EQ(0, AccessTokenDb::GetInstance().Find(
-        AtmDataType::ACCESSTOKEN_PERMISSION_STATE, conditionValue, results));
+    EXPECT_EQ(0, AccessTokenDb::GetInstance().Find(AtmDataType::ACCESSTOKEN_PERMISSION_STATE, conditionValue, results));
     for (const auto& value : results) {
         std::string permissionName = value.GetString(TokenFiledConst::FIELD_PERMISSION_NAME);
         int32_t state = value.GetInt(TokenFiledConst::FIELD_GRANT_STATE);
         int32_t flag = value.GetInt(TokenFiledConst::FIELD_GRANT_FLAG);
         if (permissionName == g_state6.permissionName) {
-            ASSERT_EQ(state, static_cast<int32_t>(PermissionState::PERMISSION_GRANTED)); // state: -1 -> 0
-            ASSERT_EQ(flag, static_cast<int32_t>(PermissionFlag::PERMISSION_SYSTEM_FIXED)); // flag: 0 -> 4
+            EXPECT_EQ(state, static_cast<int32_t>(PermissionState::PERMISSION_GRANTED)); // state: -1 -> 0
+            EXPECT_EQ(flag, static_cast<int32_t>(PermissionFlag::PERMISSION_SYSTEM_FIXED)); // flag: 0 -> 4
         }
     }
 
-    ASSERT_EQ(0, atManagerService_->DeleteToken(tokenId));
+    DelTestDataAndRestoreOri(tokenId, oriData);
 }
 
 void SetValues006(AccessTokenID tokenId, std::vector<GenericValues>& values)
@@ -743,6 +753,10 @@ void SetValues006(AccessTokenID tokenId, std::vector<GenericValues>& values)
  */
 HWTEST_F(AccessTokenManagerServiceTest, OTATest006, TestSize.Level0)
 {
+    AtmDataType type = AtmDataType::ACCESSTOKEN_HAP_UNDEFINE_INFO;
+    std::vector<GenericValues> oriData;
+    BackupAndDelOriData(oriData);
+
     HapInfoParcel infoParCel;
     infoParCel.hapInfoParameter = g_info;
     HapPolicyParcel policyParcel;
@@ -756,47 +770,43 @@ HWTEST_F(AccessTokenManagerServiceTest, OTATest006, TestSize.Level0)
 
     std::vector<GenericValues> values;
     SetValues006(tokenId, values);
+    AddInfo addInfo;
+    addInfo.addType = type;
+    addInfo.addValues = values;
 
-    std::vector<AtmDataType> deleteDataTypes;
-    std::vector<GenericValues> deleteValues;
-    std::vector<AtmDataType> addDataTypes;
-    addDataTypes.emplace_back(AtmDataType::ACCESSTOKEN_HAP_UNDEFINE_INFO);
-    std::vector<std::vector<GenericValues>> addValues;
-    addValues.emplace_back(values);
-    ASSERT_EQ(0, AccessTokenDb::GetInstance().DeleteAndInsertValues(
-        deleteDataTypes, deleteValues, addDataTypes, addValues));
-
-    addDataTypes.clear();
-    addValues.clear();
-    atManagerService_->HandleHapUndefinedInfo(tokenIdAplMap, deleteDataTypes, deleteValues, addDataTypes, addValues);
-    ASSERT_EQ(0, AccessTokenDb::GetInstance().DeleteAndInsertValues(deleteDataTypes, deleteValues, addDataTypes,
-        addValues));
+    std::vector<DelInfo> delInfoVec;
+    std::vector<AddInfo> addInfoVec;
+    addInfoVec.emplace_back(addInfo);
+    EXPECT_EQ(0, AccessTokenDb::GetInstance().DeleteAndInsertValues(delInfoVec, addInfoVec)); // add test data
+
+    std::vector<DelInfo> delInfoVec2;
+    std::vector<AddInfo> addInfoVec2;
+    atManagerService_->HandleHapUndefinedInfo(tokenIdAplMap, delInfoVec2, addInfoVec2);
+    EXPECT_EQ(0, AccessTokenDb::GetInstance().DeleteAndInsertValues(delInfoVec2, addInfoVec2));
 
     GenericValues conditionValue;
     conditionValue.Put(TokenFiledConst::FIELD_TOKEN_ID, static_cast<int32_t>(tokenId));
     std::vector<GenericValues> results;
-    ASSERT_EQ(0, AccessTokenDb::GetInstance().Find(
-        AtmDataType::ACCESSTOKEN_HAP_UNDEFINE_INFO, conditionValue, results));
-    ASSERT_EQ(true, results.empty()); // undefine table is empty
+    EXPECT_EQ(0, AccessTokenDb::GetInstance().Find(type, conditionValue, results));
+    EXPECT_EQ(true, results.empty()); // undefine table is empty
 
-    ASSERT_EQ(0, AccessTokenDb::GetInstance().Find(
-        AtmDataType::ACCESSTOKEN_PERMISSION_STATE, conditionValue, results));
+    EXPECT_EQ(0, AccessTokenDb::GetInstance().Find(AtmDataType::ACCESSTOKEN_PERMISSION_STATE, conditionValue, results));
     for (const auto& value : results) {
         std::string permissionName = value.GetString(TokenFiledConst::FIELD_PERMISSION_NAME);
         int32_t state = value.GetInt(TokenFiledConst::FIELD_GRANT_STATE);
         int32_t flag = value.GetInt(TokenFiledConst::FIELD_GRANT_FLAG);
         if (permissionName == g_state6.permissionName) {
-            ASSERT_EQ(state, static_cast<int32_t>(PermissionState::PERMISSION_GRANTED)); // state: -1 -> 0
-            ASSERT_EQ(flag, static_cast<int32_t>(PermissionFlag::PERMISSION_SYSTEM_FIXED)); // flag: 0 -> 4
+            EXPECT_EQ(state, static_cast<int32_t>(PermissionState::PERMISSION_GRANTED)); // state: -1 -> 0
+            EXPECT_EQ(flag, static_cast<int32_t>(PermissionFlag::PERMISSION_SYSTEM_FIXED)); // flag: 0 -> 4
         }
     }
 
     std::vector<GenericValues> results2;
-    ASSERT_EQ(0, AccessTokenDb::GetInstance().Find(
+    EXPECT_EQ(0, AccessTokenDb::GetInstance().Find(
         AtmDataType::ACCESSTOKEN_PERMISSION_EXTEND_VALUE, conditionValue, results2));
-    ASSERT_EQ(true, results2.empty()); // undefine table is empty
+    EXPECT_EQ(true, results2.empty()); // undefine table is empty
 
-    ASSERT_EQ(0, atManagerService_->DeleteToken(tokenId));
+    DelTestDataAndRestoreOri(tokenId, oriData);
 }
 
 void SetValues007(AccessTokenID tokenId, std::vector<GenericValues>& values)
@@ -817,6 +827,10 @@ void SetValues007(AccessTokenID tokenId, std::vector<GenericValues>& values)
  */
 HWTEST_F(AccessTokenManagerServiceTest, OTATest007, TestSize.Level0)
 {
+    AtmDataType type = AtmDataType::ACCESSTOKEN_HAP_UNDEFINE_INFO;
+    std::vector<GenericValues> oriData;
+    BackupAndDelOriData(oriData);
+
     HapInfoParcel infoParCel;
     infoParCel.hapInfoParameter = g_info;
     HapPolicyParcel policyParcel;
@@ -829,48 +843,44 @@ HWTEST_F(AccessTokenManagerServiceTest, OTATest007, TestSize.Level0)
 
     std::vector<GenericValues> values;
     SetValues007(tokenId, values);
+    AddInfo addInfo;
+    addInfo.addType = type;
+    addInfo.addValues = values;
 
-    std::vector<AtmDataType> deleteDataTypes;
-    std::vector<GenericValues> deleteValues;
-    std::vector<AtmDataType> addDataTypes;
-    addDataTypes.emplace_back(AtmDataType::ACCESSTOKEN_HAP_UNDEFINE_INFO);
-    std::vector<std::vector<GenericValues>> addValues;
-    addValues.emplace_back(values);
-    ASSERT_EQ(0, AccessTokenDb::GetInstance().DeleteAndInsertValues(
-        deleteDataTypes, deleteValues, addDataTypes, addValues));
-
-    addDataTypes.clear();
-    addValues.clear();
-    atManagerService_->HandleHapUndefinedInfo(tokenIdAplMap, deleteDataTypes, deleteValues, addDataTypes, addValues);
-    ASSERT_EQ(0, AccessTokenDb::GetInstance().DeleteAndInsertValues(deleteDataTypes, deleteValues, addDataTypes,
-        addValues));
+    std::vector<DelInfo> delInfoVec;
+    std::vector<AddInfo> addInfoVec;
+    addInfoVec.emplace_back(addInfo);
+    EXPECT_EQ(0, AccessTokenDb::GetInstance().DeleteAndInsertValues(delInfoVec, addInfoVec)); // add test data
+
+    std::vector<DelInfo> delInfoVec2;
+    std::vector<AddInfo> addInfoVec2;
+    atManagerService_->HandleHapUndefinedInfo(tokenIdAplMap, delInfoVec2, addInfoVec2);
+    EXPECT_EQ(0, AccessTokenDb::GetInstance().DeleteAndInsertValues(delInfoVec2, addInfoVec2));
 
     GenericValues conditionValue;
     conditionValue.Put(TokenFiledConst::FIELD_TOKEN_ID, static_cast<int32_t>(tokenId));
     std::vector<GenericValues> results;
-    ASSERT_EQ(0, AccessTokenDb::GetInstance().Find(
-        AtmDataType::ACCESSTOKEN_HAP_UNDEFINE_INFO, conditionValue, results));
-    ASSERT_EQ(true, results.empty()); // undefine table is empty
+    EXPECT_EQ(0, AccessTokenDb::GetInstance().Find(type, conditionValue, results));
+    EXPECT_EQ(true, results.empty()); // undefine table is empty
 
-    ASSERT_EQ(0, AccessTokenDb::GetInstance().Find(
-        AtmDataType::ACCESSTOKEN_PERMISSION_STATE, conditionValue, results));
+    EXPECT_EQ(0, AccessTokenDb::GetInstance().Find(AtmDataType::ACCESSTOKEN_PERMISSION_STATE, conditionValue, results));
     for (const auto& value : results) {
         std::string permissionName = value.GetString(TokenFiledConst::FIELD_PERMISSION_NAME);
         int32_t state = value.GetInt(TokenFiledConst::FIELD_GRANT_STATE);
         int32_t flag = value.GetInt(TokenFiledConst::FIELD_GRANT_FLAG);
         if (permissionName == g_state1.permissionName) {
-            ASSERT_EQ(state, static_cast<int32_t>(PermissionState::PERMISSION_GRANTED)); // state: -1 -> 0
-            ASSERT_EQ(flag, static_cast<int32_t>(PermissionFlag::PERMISSION_SYSTEM_FIXED)); // flag: 0 -> 4
+            EXPECT_EQ(state, static_cast<int32_t>(PermissionState::PERMISSION_GRANTED)); // state: -1 -> 0
+            EXPECT_EQ(flag, static_cast<int32_t>(PermissionFlag::PERMISSION_SYSTEM_FIXED)); // flag: 0 -> 4
         }
     }
 
     std::vector<GenericValues> results2;
-    ASSERT_EQ(0, AccessTokenDb::GetInstance().Find(
+    EXPECT_EQ(0, AccessTokenDb::GetInstance().Find(
         AtmDataType::ACCESSTOKEN_PERMISSION_EXTEND_VALUE, conditionValue, results2));
-    ASSERT_EQ(false, results2.empty()); // extend table is not empty
-    ASSERT_EQ(g_state1.permissionName, results2[0].GetString(TokenFiledConst::FIELD_PERMISSION_NAME));
+    EXPECT_EQ(false, results2.empty()); // extend table is not empty
+    EXPECT_EQ(g_state1.permissionName, results2[0].GetString(TokenFiledConst::FIELD_PERMISSION_NAME));
 
-    ASSERT_EQ(0, atManagerService_->DeleteToken(tokenId));
+    DelTestDataAndRestoreOri(tokenId, oriData);
 }
 
 /**
@@ -881,6 +891,10 @@ HWTEST_F(AccessTokenManagerServiceTest, OTATest007, TestSize.Level0)
  */
 HWTEST_F(AccessTokenManagerServiceTest, OTATest008, TestSize.Level0)
 {
+    AtmDataType type = AtmDataType::ACCESSTOKEN_HAP_UNDEFINE_INFO;
+    std::vector<GenericValues> oriData;
+    BackupAndDelOriData(oriData);
+
     HapInfoParcel infoParCel;
     infoParCel.hapInfoParameter = g_info;
     HapPolicyParcel policyParcel;
@@ -895,47 +909,40 @@ HWTEST_F(AccessTokenManagerServiceTest, OTATest008, TestSize.Level0)
     value.Put(TokenFiledConst::FIELD_TOKEN_ID, static_cast<int32_t>(tokenId));
     value.Put(TokenFiledConst::FIELD_PERMISSION_NAME, g_state1.permissionName);
     value.Put(TokenFiledConst::FIELD_ACL, 0); // system core permission without acl and without value
-    std::vector<GenericValues> values;
-    values.emplace_back(value);
+    AddInfo addInfo;
+    addInfo.addType = type;
+    addInfo.addValues.emplace_back(value);
+
+    std::vector<DelInfo> delInfoVec;
+    std::vector<AddInfo> addInfoVec;
+    addInfoVec.emplace_back(addInfo);
+    EXPECT_EQ(0, AccessTokenDb::GetInstance().DeleteAndInsertValues(delInfoVec, addInfoVec)); // add test data
 
-    std::vector<AtmDataType> deleteDataTypes;
-    std::vector<GenericValues> deleteValues;
-    std::vector<AtmDataType> addDataTypes;
-    addDataTypes.emplace_back(AtmDataType::ACCESSTOKEN_HAP_UNDEFINE_INFO);
-    std::vector<std::vector<GenericValues>> addValues;
-    addValues.emplace_back(values);
-    ASSERT_EQ(0, AccessTokenDb::GetInstance().DeleteAndInsertValues(
-        deleteDataTypes, deleteValues, addDataTypes, addValues));
-
-    std::vector<AtmDataType> deleteDataTypes2;
-    std::vector<GenericValues> deleteValues2;
-    std::vector<AtmDataType> addDataTypes2;
-    std::vector<std::vector<GenericValues>> addValues2;
-    atManagerService_->HandleHapUndefinedInfo(tokenIdAplMap, deleteDataTypes2, deleteValues2, addDataTypes2,
-        addValues2);
-    ASSERT_EQ(0, AccessTokenDb::GetInstance().DeleteAndInsertValues(deleteDataTypes2, deleteValues2, addDataTypes2,
-        addValues2));
+    std::vector<DelInfo> delInfoVec2;
+    std::vector<AddInfo> addInfoVec2;
+    atManagerService_->HandleHapUndefinedInfo(tokenIdAplMap, delInfoVec2, addInfoVec2);
+    EXPECT_EQ(0, AccessTokenDb::GetInstance().DeleteAndInsertValues(delInfoVec2, addInfoVec2));
 
     GenericValues conditionValue;
     conditionValue.Put(TokenFiledConst::FIELD_TOKEN_ID, static_cast<int32_t>(tokenId));
     std::vector<GenericValues> results;
-    ASSERT_EQ(0, AccessTokenDb::GetInstance().Find(
+    EXPECT_EQ(0, AccessTokenDb::GetInstance().Find(
         AtmDataType::ACCESSTOKEN_HAP_UNDEFINE_INFO, conditionValue, results));
-    ASSERT_EQ(false, results.empty()); // undefine table is not empty
+    EXPECT_EQ(false, results.empty()); // undefine table is not empty
 
     std::vector<GenericValues> results2;
-    ASSERT_EQ(0, AccessTokenDb::GetInstance().Find(
+    EXPECT_EQ(0, AccessTokenDb::GetInstance().Find(
         AtmDataType::ACCESSTOKEN_PERMISSION_STATE, conditionValue, results2));
     for (const auto& value : results2) {
-        ASSERT_NE(value.GetString(TokenFiledConst::FIELD_PERMISSION_NAME), g_state1.permissionName);
+        EXPECT_NE(value.GetString(TokenFiledConst::FIELD_PERMISSION_NAME), g_state1.permissionName);
     }
 
     std::vector<GenericValues> results3;
-    ASSERT_EQ(0, AccessTokenDb::GetInstance().Find(
+    EXPECT_EQ(0, AccessTokenDb::GetInstance().Find(
         AtmDataType::ACCESSTOKEN_PERMISSION_EXTEND_VALUE, conditionValue, results3));
-    ASSERT_EQ(true, results3.empty()); // extend table is empty
+    EXPECT_EQ(true, results3.empty()); // extend table is empty
 
-    ASSERT_EQ(0, atManagerService_->DeleteToken(tokenId));
+    DelTestDataAndRestoreOri(tokenId, oriData);
 }
 
 /**
diff --git a/services/accesstokenmanager/test/unittest/accesstoken_manager_service_test.h b/services/accesstokenmanager/test/unittest/accesstoken_manager_service_test.h
index f6045fe9f78f366a2aa053f9be0395b74d454a7e..6dadf34bb66d56c4dc9226e412ca2cfa7ae2267f 100644
--- a/services/accesstokenmanager/test/unittest/accesstoken_manager_service_test.h
+++ b/services/accesstokenmanager/test/unittest/accesstoken_manager_service_test.h
@@ -34,6 +34,7 @@ public:
     void TearDown();
     void CreateHapToken(const HapInfoParcel& infoParCel, const HapPolicyParcel& policyParcel, AccessTokenID& tokenId,
         std::map<int32_t, int32_t>& tokenIdAplMap, bool hasInit = false);
+    void DelTestDataAndRestoreOri(AccessTokenID tokenId, const std::vector<GenericValues>& oriData);
 
     std::shared_ptr<AccessTokenManagerService> atManagerService_;
 };
diff --git a/services/common/database/test/unittest/database_test.cpp b/services/common/database/test/unittest/database_test.cpp
index 24c75356ffa94d657a7fa4c0671a4e06e8c1fda7..3c6f316f3ad9390121c4f424964114d576544379 100644
--- a/services/common/database/test/unittest/database_test.cpp
+++ b/services/common/database/test/unittest/database_test.cpp
@@ -138,14 +138,14 @@ static void RemoveTestTokenHapInfo()
 {
     GenericValues condition;
     condition.Put(TokenFiledConst::FIELD_TOKEN_ID, static_cast<int32_t>(TEST_TOKEN_ID));
-    std::vector<AtmDataType> deleteDataTypes;
-    std::vector<GenericValues> deleteValues;
-    deleteDataTypes.emplace_back(AtmDataType::ACCESSTOKEN_HAP_INFO);
-    deleteValues.emplace_back(condition);
-
-    std::vector<AtmDataType> addDataTypes;
-    std::vector<std::vector<GenericValues>> addValues;
-    AccessTokenDb::GetInstance().DeleteAndInsertValues(deleteDataTypes, deleteValues, addDataTypes, addValues);
+    DelInfo delInfo;
+    delInfo.delType = AtmDataType::ACCESSTOKEN_HAP_INFO;
+    delInfo.delValue = condition;
+
+    std::vector<DelInfo> delInfoVec;
+    delInfoVec.emplace_back(delInfo);
+    std::vector<AddInfo> addInfoVec;
+    AccessTokenDb::GetInstance().DeleteAndInsertValues(delInfoVec, addInfoVec);
 }
 
 /*
@@ -173,18 +173,14 @@ HWTEST_F(DatabaseTest, SqliteStorageModifyTest001, TestSize.Level0)
     genericValues.Put(TokenFiledConst::FIELD_TOKEN_VERSION, 0);
     genericValues.Put(TokenFiledConst::FIELD_TOKEN_ATTR, 0);
     genericValues.Put(TokenFiledConst::FIELD_FORBID_PERM_DIALOG, "test_perm_dialog_cap_state");
-
-    std::vector<AtmDataType> deleteDataTypes;
-    std::vector<GenericValues> deleteValues;
-
-    std::vector<AtmDataType> addDataTypes;
-    std::vector<std::vector<GenericValues>> addValues;
-    std::vector<GenericValues> value;
-    addDataTypes.emplace_back(AtmDataType::ACCESSTOKEN_HAP_INFO);
-    value.emplace_back(genericValues);
-    addValues.emplace_back(value);
-    EXPECT_EQ(0,
-        AccessTokenDb::GetInstance().DeleteAndInsertValues(deleteDataTypes, deleteValues, addDataTypes, addValues));
+    AddInfo addInfo;
+    addInfo.addType = AtmDataType::ACCESSTOKEN_HAP_INFO;
+    addInfo.addValues.emplace_back(genericValues);
+
+    std::vector<DelInfo> delInfoVec;
+    std::vector<AddInfo> addInfoVec;
+    addInfoVec.emplace_back(addInfo);
+    EXPECT_EQ(0, AccessTokenDb::GetInstance().DeleteAndInsertValues(delInfoVec, addInfoVec));
 
     GenericValues modifyValues;
     modifyValues.Put(TokenFiledConst::FIELD_BUNDLE_NAME, "test_bundle_name_modified");