diff --git a/services/distributeddataservice/framework/include/metadata/store_meta_data.h b/services/distributeddataservice/framework/include/metadata/store_meta_data.h
index 7aa999697581d3427e45bd4fe9636526a14d2613..201fccc012261462b78233df92c347abfb934425 100644
--- a/services/distributeddataservice/framework/include/metadata/store_meta_data.h
+++ b/services/distributeddataservice/framework/include/metadata/store_meta_data.h
@@ -117,7 +117,6 @@ struct API_EXPORT StoreMetaMapping final : public StoreMetaData {
     API_EXPORT std::string GetKey() const override;
     API_EXPORT std::string GetCloudStoreMetaKey() const;
     API_EXPORT std::string GetDeviceStoreMetaKey() const;
-    API_EXPORT std::string GetSearchStoreMetaKey() const;
     API_EXPORT static std::string GetPrefix(const std::initializer_list<std::string> &fields);
     API_EXPORT StoreMetaMapping& operator=(const StoreMetaData &meta);
 
diff --git a/services/distributeddataservice/framework/include/store/auto_cache.h b/services/distributeddataservice/framework/include/store/auto_cache.h
index 3a1572945837bb07d0cb6b333f31253121a4d23e..be03ada1becdf6aeb32e0414f58fd50d2b491482 100644
--- a/services/distributeddataservice/framework/include/store/auto_cache.h
+++ b/services/distributeddataservice/framework/include/store/auto_cache.h
@@ -52,21 +52,24 @@ public:
 
     API_EXPORT std::pair<int32_t, Store> GetDBStore(const StoreMetaData &meta, const Watchers &watchers);
 
-    API_EXPORT Stores GetStoresIfPresent(uint32_t tokenId, const std::string &path = "");
-
-    API_EXPORT void CloseStore(uint32_t tokenId, const std::string &path = "");
+    API_EXPORT Stores GetStoresIfPresent(
+        uint32_t tokenId, const std::string &path = "", const std::string &storeId = "");
 
+    API_EXPORT void CloseStore(uint32_t tokenId, const std::string &path = "", const std::string &storeId = "");
+ 
     API_EXPORT void CloseStore(const Filter &filter);
-
-    API_EXPORT void SetObserver(uint32_t tokenId, const Watchers &watchers, const std::string &path);
-
-    API_EXPORT void Enable(uint32_t tokenId, const std::string &path = "");
-
-    API_EXPORT void Disable(uint32_t tokenId, const std::string &path = "");
+ 
+    API_EXPORT void SetObserver(
+        uint32_t tokenId, const Watchers &watchers, const std::string &path, const std::string &storeId = "");
+ 
+    API_EXPORT void Enable(uint32_t tokenId, const std::string &path = "", const std::string &storeId = "");
+ 
+    API_EXPORT void Disable(uint32_t tokenId, const std::string &path = "", const std::string &storeId = "");
 
 private:
     AutoCache();
     ~AutoCache();
+    std::string GenerateKey(const std::string &path, const std::string &storeId) const;
     void GarbageCollect(bool isForce);
     void StartTimer();
     struct Delegate : public GeneralWatcher {
diff --git a/services/distributeddataservice/framework/metadata/store_meta_data.cpp b/services/distributeddataservice/framework/metadata/store_meta_data.cpp
index 41ecb84f6df1168e80f71aaaef826f768be6c746..3dba8c533027f644a21d44a3130f00e9bc748126 100644
--- a/services/distributeddataservice/framework/metadata/store_meta_data.cpp
+++ b/services/distributeddataservice/framework/metadata/store_meta_data.cpp
@@ -323,11 +323,6 @@ std::string StoreMetaMapping::GetDeviceStoreMetaKey() const
     return GetStoreMetaKeyWithPath(devicePath);
 }
 
-std::string StoreMetaMapping::GetSearchStoreMetaKey() const
-{
-    return GetStoreMetaKeyWithPath(searchPath);
-}
-
 std::string StoreMetaMapping::GetPrefix(const std::initializer_list<std::string> &fields)
 {
     return GetKey(fields).append(Constant::KEY_SEPARATOR);
diff --git a/services/distributeddataservice/framework/store/auto_cache.cpp b/services/distributeddataservice/framework/store/auto_cache.cpp
index 9e1cbef7450cb0846d5d3fd46480701a1678eab5..4253619e56be45d32ff38c87bcd8ead55530fc25 100644
--- a/services/distributeddataservice/framework/store/auto_cache.cpp
+++ b/services/distributeddataservice/framework/store/auto_cache.cpp
@@ -25,6 +25,7 @@
 #include "utils/anonymous.h"
 namespace OHOS::DistributedData {
 using Account = AccountDelegate;
+static constexpr const char *KEY_SEPARATOR = "###";
 AutoCache &AutoCache::GetInstance()
 {
     static AutoCache cache;
@@ -60,10 +61,19 @@ AutoCache::~AutoCache()
     }
 }
 
+std::string AutoCache::GenerateKey(const std::string &path, const std::string &storeId) const
+{
+    std::string key = "";
+    if (path.empty() || storeId.empty()) {
+        return key;
+    }
+    return key.append(path).append(KEY_SEPARATOR).append(storeId);
+}
+
 std::pair<int32_t, AutoCache::Store> AutoCache::GetDBStore(const StoreMetaData &meta, const Watchers &watchers)
 {
     Store store;
-    auto storeKey = meta.dataDir;
+    auto storeKey = GenerateKey(meta.dataDir, meta.storeId);
     if (meta.storeType >= MAX_CREATOR_NUM || meta.storeType < 0 || !creators_[meta.storeType] ||
         disables_.ContainIf(meta.tokenId,
             [&storeKey](const std::set<std::string> &stores) -> bool { return stores.count(storeKey) != 0; })) {
@@ -117,17 +127,18 @@ AutoCache::Store AutoCache::GetStore(const StoreMetaData &meta, const Watchers &
     return GetDBStore(meta, watchers).second;
 }
 
-AutoCache::Stores AutoCache::GetStoresIfPresent(uint32_t tokenId, const std::string &path)
+AutoCache::Stores AutoCache::GetStoresIfPresent(uint32_t tokenId, const std::string &path, const std::string &storeName)
 {
     Stores stores;
+    auto storeKey = GenerateKey(path, storeName);
     stores_.ComputeIfPresent(
-        tokenId, [&stores, &path](auto &, std::map<std::string, Delegate> &delegates) -> bool {
-            if (path.empty()) {
+        tokenId, [&stores, &storeKey](auto &, std::map<std::string, Delegate> &delegates) -> bool {
+            if (storeKey.empty()) {
                 for (auto &[_, delegate] : delegates) {
                     stores.push_back(delegate);
                 }
             } else {
-                auto it = delegates.find(path);
+                auto it = delegates.find(storeKey);
                 if (it != delegates.end()) {
                     stores.push_back(it->second);
                 }
@@ -159,17 +170,18 @@ void AutoCache::StartTimer()
     ZLOGD("start timer,taskId: %{public}" PRIu64, taskId_);
 }
 
-void AutoCache::CloseStore(uint32_t tokenId, const std::string &path)
+void AutoCache::CloseStore(uint32_t tokenId, const std::string &path, const std::string &storeId)
 {
-    ZLOGD("close store start, token:%{public}u", tokenId);
+    ZLOGD("close store start, store:%{public}s, token:%{public}u", Anonymous::Change(storeId).c_str(), tokenId);
     std::set<std::string> storeIds;
     std::list<Delegate> closeStores;
     bool isScreenLocked = ScreenManager::GetInstance()->IsLocked();
+    auto storeKey = GenerateKey(path, storeId);
     stores_.ComputeIfPresent(tokenId,
-        [this, &path, isScreenLocked, &storeIds, &closeStores](auto &, auto &delegates) {
+        [this, &storeKey, isScreenLocked, &storeIds, &closeStores](auto &, auto &delegates) {
             auto it = delegates.begin();
             while (it != delegates.end()) {
-                if ((it->first == path || path.empty()) &&
+                if ((it->first == storeKey || storeKey.empty()) &&
                     (!isScreenLocked || it->second.GetArea() != GeneralStore::EL4) &&
                     disableStores_.count(it->second.GetDataDir()) == 0) {
                     disableStores_.insert(it->second.GetDataDir());
@@ -229,12 +241,14 @@ void AutoCache::CloseStore(const AutoCache::Filter &filter)
     });
 }
 
-void AutoCache::SetObserver(uint32_t tokenId, const AutoCache::Watchers &watchers, const std::string &path)
+void AutoCache::SetObserver(uint32_t tokenId, const AutoCache::Watchers &watchers, const std::string &path,
+    const std::string &storeId)
 {
-    stores_.ComputeIfPresent(tokenId, [&path, &watchers](auto &key, auto &stores) {
+    auto storeKey = GenerateKey(path, storeId);
+    stores_.ComputeIfPresent(tokenId, [&storeKey, &watchers](auto &key, auto &stores) {
         ZLOGD("tokenId:0x%{public}x storeId:%{public}s observers:%{public}zu", key,
-            Anonymous::Change(path).c_str(), watchers.size());
-        auto it = stores.find(path);
+            Anonymous::Change(storeKey).c_str(), watchers.size());
+        auto it = stores.find(storeKey);
         if (it != stores.end()) {
             it->second.SetObservers(watchers);
         }
@@ -260,21 +274,23 @@ void AutoCache::GarbageCollect(bool isForce)
     });
 }
 
-void AutoCache::Enable(uint32_t tokenId, const std::string &path)
+void AutoCache::Enable(uint32_t tokenId, const std::string &path, const std::string &storeId)
 {
-    disables_.ComputeIfPresent(tokenId, [&path](auto key, std::set<std::string> &stores) {
-        stores.erase(path);
-        return !(stores.empty() || path.empty());
+    auto storeKey = GenerateKey(path, storeId);
+    disables_.ComputeIfPresent(tokenId, [&storeKey](auto key, std::set<std::string> &stores) {
+        stores.erase(storeKey);
+        return !(stores.empty() || storeKey.empty());
     });
 }
 
-void AutoCache::Disable(uint32_t tokenId, const std::string &path)
+void AutoCache::Disable(uint32_t tokenId, const std::string &path, const std::string &storeId)
 {
-    disables_.Compute(tokenId, [&path](auto key, std::set<std::string> &stores) {
-        stores.insert(path);
+    auto storeKey = GenerateKey(path, storeId);
+    disables_.Compute(tokenId, [&storeKey](auto key, std::set<std::string> &stores) {
+        stores.insert(storeKey);
         return !stores.empty();
     });
-    CloseStore(tokenId, path);
+    CloseStore(tokenId, path, storeId);
 }
 
 AutoCache::Delegate::Delegate(GeneralStore *delegate, const Watchers &watchers, int32_t user, const StoreMetaData &meta)
diff --git a/services/distributeddataservice/service/cloud/sync_manager.cpp b/services/distributeddataservice/service/cloud/sync_manager.cpp
index 39a046674500c147b75a41a970c693c24853a890..d35bd45e87626780c474155eaf21e403ca03d144 100644
--- a/services/distributeddataservice/service/cloud/sync_manager.cpp
+++ b/services/distributeddataservice/service/cloud/sync_manager.cpp
@@ -973,9 +973,6 @@ void SyncManager::BatchReport(int32_t userId, const TraceIds &traceIds, SyncStag
 
 std::string SyncManager::GetPath(const StoreMetaData &meta)
 {
-    if (!meta.dataDir.empty()) {
-        return meta.dataDir;
-    }
     StoreMetaMapping mapping(meta);
     MetaDataManager::GetInstance().LoadMeta(mapping.GetKey(), mapping, true);
     return mapping.cloudPath.empty() ? mapping.dataDir : mapping.cloudPath;
diff --git a/services/distributeddataservice/service/kvdb/kvdb_service_impl.cpp b/services/distributeddataservice/service/kvdb/kvdb_service_impl.cpp
index 4aa437cbcca79c75abd356630f8a1c23ac6a1746..e8e05f011616f8e5cf61e2e6da53fc5cecb3d678 100644
--- a/services/distributeddataservice/service/kvdb/kvdb_service_impl.cpp
+++ b/services/distributeddataservice/service/kvdb/kvdb_service_impl.cpp
@@ -111,8 +111,8 @@ void KVDBServiceImpl::Init()
             }
             meta.user = "0";
             StoreMetaDataLocal localMeta;
-            if (!MetaDataManager::GetInstance().LoadMeta(meta.GetKeyLocal(), localMeta, true) || !localMeta.isPublic ||
-                !MetaDataManager::GetInstance().LoadMeta(meta.GetKey(), meta, true)) {
+            if (!MetaDataManager::GetInstance().LoadMeta(meta.GetKey(), meta, true) ||
+                !MetaDataManager::GetInstance().LoadMeta(meta.GetKeyLocal(), localMeta, true) || !localMeta.isPublic) {
                 ZLOGE("meta empty, not public store. bundleName:%{public}s, storeId:%{public}s, user = %{public}s",
                     meta.bundleName.c_str(), meta.GetStoreAlias().c_str(), meta.user.c_str());
                 return;
@@ -217,7 +217,7 @@ Status KVDBServiceImpl::Close(const AppId &appId, const StoreId &storeId, int32_
     if (metaData.instanceId < 0) {
         return ILLEGAL_STATE;
     }
-    AutoCache::GetInstance().CloseStore(metaData.tokenId, metaData.dataDir);
+    AutoCache::GetInstance().CloseStore(metaData.tokenId, metaData.dataDir, storeId);
     ZLOGD("appId:%{public}s storeId:%{public}s instanceId:%{public}d", appId.appId.c_str(),
         Anonymous::Change(storeId.storeId).c_str(), metaData.instanceId);
     return SUCCESS;
@@ -577,7 +577,7 @@ Status KVDBServiceImpl::Subscribe(const AppId &appId, const StoreId &storeId, in
     });
     if (isCreate) {
         AutoCache::GetInstance().SetObserver(metaData.tokenId,
-            GetWatchers(metaData.tokenId, storeId, metaData.user), metaData.dataDir);
+            GetWatchers(metaData.tokenId, storeId, metaData.user), metaData.dataDir, storeId);
     }
     return SUCCESS;
 }
@@ -609,7 +609,7 @@ Status KVDBServiceImpl::Unsubscribe(const AppId &appId, const StoreId &storeId,
     });
     if (destroyed) {
         AutoCache::GetInstance().SetObserver(metaData.tokenId,
-            GetWatchers(metaData.tokenId, storeId, metaData.user), metaData.dataDir);
+            GetWatchers(metaData.tokenId, storeId, metaData.user), metaData.dataDir, storeId);
     }
     return SUCCESS;
 }
@@ -695,7 +695,7 @@ Status KVDBServiceImpl::SetConfig(const AppId &appId, const StoreId &storeId, co
             return Status::ERROR;
         }
     }
-    auto stores = AutoCache::GetInstance().GetStoresIfPresent(meta.tokenId, meta.dataDir);
+    auto stores = AutoCache::GetInstance().GetStoresIfPresent(meta.tokenId, meta.dataDir, storeId);
     for (auto store : stores) {
         store->SetConfig({ storeConfig.cloudConfig.enableCloud });
     }
diff --git a/services/distributeddataservice/service/rdb/rdb_service_impl.cpp b/services/distributeddataservice/service/rdb/rdb_service_impl.cpp
index 3f2341deee1ea01f3f530b26f7b4e97a24ba5f95..43c0c7cfb7742388bdae43d9884de443089ea025 100644
--- a/services/distributeddataservice/service/rdb/rdb_service_impl.cpp
+++ b/services/distributeddataservice/service/rdb/rdb_service_impl.cpp
@@ -636,7 +636,7 @@ int32_t RdbServiceImpl::Subscribe(const RdbSyncerParam &param, const SubscribeOp
     });
     if (isCreate) {
         AutoCache::GetInstance().SetObserver(tokenId, GetWatchers(tokenId, param.storeName_),
-            GetPath(param));
+            GetPath(param), RemoveSuffix(param.storeName_));
     }
     return RDB_OK;
 }
@@ -665,7 +665,7 @@ int32_t RdbServiceImpl::UnSubscribe(const RdbSyncerParam &param, const Subscribe
     });
     if (destroyed) {
         AutoCache::GetInstance().SetObserver(tokenId, GetWatchers(tokenId, param.storeName_),
-            GetPath(param));
+            GetPath(param), RemoveSuffix(param.storeName_));
     }
     return RDB_OK;
 }
@@ -723,15 +723,13 @@ int32_t RdbServiceImpl::Delete(const RdbSyncerParam &param)
         return RDB_ERROR;
     }
     auto tokenId = IPCSkeleton::GetCallingTokenID();
-    if (param.bundleName_.empty()) {
-        ZLOGE("bundleName is empty! tokenId:%{public}d.", tokenId);
-        return RDB_ERROR;
-    }
     auto storeMeta = GetStoreMetaData(param);
     StoreMetaMapping storeMetaMapping(storeMeta);
     MetaDataManager::GetInstance().LoadMeta(storeMetaMapping.GetKey(), storeMetaMapping, true);
-    storeMeta.dataDir = storeMetaMapping.dataDir;
-    AutoCache::GetInstance().CloseStore(tokenId, storeMeta.dataDir);
+    if (!MetaDataManager::GetInstance().LoadMeta(storeMeta.GetKey(), storeMeta, true)) {
+        storeMeta.dataDir = storeMetaMapping.dataDir;
+    }
+    AutoCache::GetInstance().CloseStore(tokenId, storeMeta.dataDir, RemoveSuffix(param.storeName_));
     MetaDataManager::GetInstance().DelMeta(storeMeta.GetKeyWithoutPath());
     MetaDataManager::GetInstance().DelMeta(storeMeta.GetKey(), true);
     MetaDataManager::GetInstance().DelMeta(storeMeta.GetKeyLocal(), true);
@@ -872,9 +870,8 @@ int32_t RdbServiceImpl::BeforeOpen(RdbSyncerParam &param)
             Anonymous::Change(param.storeName_).c_str());
         return RDB_ERROR;
     }
-    auto meta = GetStoreMetaData(param);
-    auto isCreated = MetaDataManager::GetInstance().LoadMeta(meta.GetKey(), meta, true);
-    if (!isCreated) {
+    auto [exist, meta] = LoadStoreMetaData(param);
+    if (!exist) {
         ZLOGW("bundleName:%{public}s, storeName:%{public}s. no meta", param.bundleName_.c_str(),
             Anonymous::Change(param.storeName_).c_str());
         return RDB_NO_META;
@@ -1034,6 +1031,33 @@ void RdbServiceImpl::GetSchema(const RdbSyncerParam &param)
     }
 }
 
+std::pair<bool, StoreMetaData> RdbServiceImpl::LoadStoreMetaData(const RdbSyncerParam &param)
+{
+    StoreMetaData metaData;
+    metaData.uid = IPCSkeleton::GetCallingUid();
+    metaData.tokenId = IPCSkeleton::GetCallingTokenID();
+    auto [instanceId, user] = GetInstIndexAndUser(metaData.tokenId, param.bundleName_);
+    metaData.instanceId = instanceId;
+    metaData.bundleName = param.bundleName_;
+    metaData.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid;
+    metaData.storeId = RemoveSuffix(param.storeName_);
+    if (AccessTokenKit::GetTokenTypeFlag(metaData.tokenId) != TOKEN_HAP && param.subUser_ != 0) {
+        metaData.user = std::to_string(param.subUser_);
+    } else {
+        metaData.user = std::to_string(user);
+    }
+    metaData.storeType = param.type_;
+    metaData.securityLevel = param.level_;
+    metaData.area = param.area_;
+    metaData.appId = CheckerManager::GetInstance().GetAppId(Converter::ConvertToStoreInfo(metaData));
+    metaData.appType = "harmony";
+    metaData.hapName = param.hapName_;
+    metaData.customDir = param.customDir_;
+    metaData.dataDir = DirectoryManager::GetInstance().GetStorePath(metaData) + "/" + param.storeName_;
+    auto exist = MetaDataManager::GetInstance().LoadMeta(metaData.GetKey(), metaData, true);
+    return {exist, metaData};
+}
+
 StoreMetaData RdbServiceImpl::GetStoreMetaData(const RdbSyncerParam &param)
 {
     StoreMetaData metaData;
@@ -1509,8 +1533,7 @@ int32_t RdbServiceImpl::Disable(const RdbSyncerParam &param)
 {
     auto tokenId = IPCSkeleton::GetCallingTokenID();
     auto storeId = RemoveSuffix(param.storeName_);
-    auto userId = GetSubUser(param.subUser_);
-    AutoCache::GetInstance().Disable(tokenId, GetPath(param));
+    AutoCache::GetInstance().Disable(tokenId, GetPath(param), storeId);
     return RDB_OK;
 }
 
@@ -1518,8 +1541,7 @@ int32_t RdbServiceImpl::Enable(const RdbSyncerParam &param)
 {
     auto tokenId = IPCSkeleton::GetCallingTokenID();
     auto storeId = RemoveSuffix(param.storeName_);
-    auto userId = GetSubUser(param.subUser_);
-    AutoCache::GetInstance().Enable(tokenId, GetPath(param));
+    AutoCache::GetInstance().Enable(tokenId, GetPath(param), storeId);
     return RDB_OK;
 }
 
@@ -1733,15 +1755,16 @@ int32_t RdbServiceImpl::VerifyPromiseInfo(const RdbSyncerParam &param)
     auto tokenId = IPCSkeleton::GetCallingTokenID();
     auto uid = IPCSkeleton::GetCallingUid();
     meta.user = param.user_;
-    StoreMetaMapping metaMapping(meta);
-    MetaDataManager::GetInstance().LoadMeta(metaMapping.GetKey(), metaMapping, true);
-    meta.dataDir = metaMapping.dataDir;
     StoreMetaDataLocal localMeta;
-    auto isCreated = MetaDataManager::GetInstance().LoadMeta(meta.GetKeyLocal(), localMeta, true);
-    if (!isCreated) {
-        ZLOGE("Store not exist. bundleName:%{public}s, storeName:%{public}s", meta.bundleName.c_str(),
-            meta.GetStoreAlias().c_str());
-        return RDB_ERROR;
+    if (!MetaDataManager::GetInstance().LoadMeta(meta.GetKeyLocal(), localMeta, true)) {
+        StoreMetaMapping metaMapping(meta);
+        MetaDataManager::GetInstance().LoadMeta(metaMapping.GetKey(), metaMapping, true);
+        meta.dataDir = metaMapping.dataDir;
+        if (!MetaDataManager::GetInstance().LoadMeta(meta.GetKeyLocal(), localMeta, true)) {
+            ZLOGE("Store not exist. bundleName:%{public}s, storeName:%{public}s", meta.bundleName.c_str(),
+                meta.GetStoreAlias().c_str());
+            return RDB_ERROR;
+        }
     }
     ATokenTypeEnum type = AccessTokenKit::GetTokenType(tokenId);
     if (type == ATokenTypeEnum::TOKEN_NATIVE || type == ATokenTypeEnum::TOKEN_SHELL) {
diff --git a/services/distributeddataservice/service/rdb/rdb_service_impl.h b/services/distributeddataservice/service/rdb/rdb_service_impl.h
index 5dffb4dcd82e8a8f36976f0bb433aed85bfded1f..b7fe3c03c401819504d293ea15f227ef7ceed66d 100644
--- a/services/distributeddataservice/service/rdb/rdb_service_impl.h
+++ b/services/distributeddataservice/service/rdb/rdb_service_impl.h
@@ -221,6 +221,8 @@ private:
 
     static StoreMetaData GetStoreMetaData(const RdbSyncerParam &param);
 
+    static std::pair<bool, StoreMetaData> LoadStoreMetaData(const RdbSyncerParam &param);
+
     static std::string GetPath(const RdbSyncerParam &param);
 
     static StoreMetaData GetStoreMetaData(const Database &dataBase);
diff --git a/services/distributeddataservice/service/rdb/rdb_service_stub.cpp b/services/distributeddataservice/service/rdb/rdb_service_stub.cpp
old mode 100755
new mode 100644
diff --git a/services/distributeddataservice/service/test/BUILD.gn b/services/distributeddataservice/service/test/BUILD.gn
index 1f6ecbcfdfb96958d59b23c6e105f906d9608ef1..98c13fef7209ebd20d4b87ac18c56c8738452f45 100644
--- a/services/distributeddataservice/service/test/BUILD.gn
+++ b/services/distributeddataservice/service/test/BUILD.gn
@@ -57,6 +57,7 @@ ohos_unittest("CloudDataTest") {
     cfi = true
     cfi_cross_dso = true
     debug = false
+    blocklist = "${datamgr_service_path}/cfi_blocklist.txt"
   }
   module_out_path = module_output_path
   sources = [
@@ -850,6 +851,7 @@ ohos_unittest("ObjectDmsHandlerTest") {
     cfi = true
     cfi_cross_dso = true
     debug = false
+    blocklist = "${datamgr_service_path}/cfi_blocklist.txt"
   }
   module_out_path = module_output_path
   sources = [
diff --git a/services/distributeddataservice/service/test/cloud_service_impl_test.cpp b/services/distributeddataservice/service/test/cloud_service_impl_test.cpp
index dbe572a55aab8c2a40429bbf4b223fd8c511d082..ed40cca5ad9eef4a73600c10d12b4b360a081ec5 100644
--- a/services/distributeddataservice/service/test/cloud_service_impl_test.cpp
+++ b/services/distributeddataservice/service/test/cloud_service_impl_test.cpp
@@ -15,7 +15,6 @@
 #define LOG_TAG "CloudServiceImplTest"
 #include "cloud_service_impl.h"
 
-#include <gmock/gmock.h>
 #include <gtest/gtest.h>
 #include <unistd.h>
 
@@ -53,6 +52,7 @@
 #include "store/auto_cache.h"
 #include "store/store_info.h"
 #include "token_setproc.h"
+#include "directory/directory_manager.h"
 
 using namespace testing::ext;
 using namespace testing;
@@ -61,6 +61,7 @@ using namespace OHOS::Security::AccessToken;
 using Confirmation = OHOS::CloudData::Confirmation;
 using Status = OHOS::CloudData::CloudService::Status;
 using CloudSyncScene = OHOS::CloudData::CloudServiceImpl::CloudSyncScene;
+using DmAdapter = OHOS::DistributedData::DeviceManagerAdapter;
 
 namespace OHOS::Test {
 namespace DistributedDataTest {
@@ -75,30 +76,71 @@ public:
     void SetUp();
     void TearDown();
 
+    static void InitMetaData();
+    static void CheckDelMeta(StoreMetaMapping &metaMapping, StoreMetaData &meta, StoreMetaData &meta1);
     static std::shared_ptr<CloudData::CloudServiceImpl> cloudServiceImpl_;
-    static inline std::shared_ptr<MetaDataManagerMock> metaDataManagerMock = nullptr;
     static NetworkDelegateMock delegate_;
+protected:
+    static std::shared_ptr<DBStoreMock> dbStoreMock_;
+    static StoreMetaData metaData_;
 };
 std::shared_ptr<CloudData::CloudServiceImpl> CloudServiceImplTest::cloudServiceImpl_ =
     std::make_shared<CloudData::CloudServiceImpl>();
 NetworkDelegateMock CloudServiceImplTest::delegate_;
+std::shared_ptr<DBStoreMock> CloudServiceImplTest::dbStoreMock_ = std::make_shared<DBStoreMock>();
+StoreMetaData CloudServiceImplTest::metaData_;
+
+void CloudServiceImplTest::CheckDelMeta(StoreMetaMapping &metaMapping, StoreMetaData &meta, StoreMetaData &meta1)
+{
+    EXPECT_EQ(MetaDataManager::GetInstance().DelMeta(metaMapping.GetKey(), true), true);
+    EXPECT_EQ(MetaDataManager::GetInstance().DelMeta(meta1.GetKey(), true), true);
+    metaMapping.cloudPath = "";
+    metaMapping.dataDir = DirectoryManager::GetInstance().GetStorePath(metaMapping) + "/" + metaMapping.storeId;
+    EXPECT_EQ(MetaDataManager::GetInstance().SaveMeta(metaMapping.GetKey(), metaMapping, true), true);
+    EXPECT_EQ(MetaDataManager::GetInstance().SaveMeta(meta1.GetKey(), meta1, true), true);
+    meta.user = "100";
+    auto res = cloudServiceImpl_->GetStoreMetaData(meta);
+    EXPECT_EQ(res, false);
+ 
+    EXPECT_EQ(MetaDataManager::GetInstance().DelMeta(metaMapping.GetKey(), true), true);
+    EXPECT_EQ(MetaDataManager::GetInstance().DelMeta(meta1.GetKey(), true), true);
+    metaMapping.dataDir = "";
+    EXPECT_EQ(MetaDataManager::GetInstance().SaveMeta(metaMapping.GetKey(), metaMapping, true), true);
+    EXPECT_EQ(MetaDataManager::GetInstance().SaveMeta(meta1.GetKey(), meta1, true), true);
+    meta.user = "100";
+    res = cloudServiceImpl_->GetStoreMetaData(meta);
+    EXPECT_EQ(res, false);
+}
+
+void CloudServiceImplTest::InitMetaData()
+{
+    metaData_.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid;
+    metaData_.appId = "test_rdb_cloud_service_impl_appid";
+    metaData_.bundleName = "test_rdb_cloud_service_impl_bundleName";
+    metaData_.tokenId = OHOS::IPCSkeleton::GetCallingTokenID();
+    metaData_.user = std::to_string(AccountDelegate::GetInstance()->GetUserByToken(metaData_.tokenId));
+    metaData_.area = OHOS::DistributedKv::EL1;
+    metaData_.instanceId = 0;
+    metaData_.isAutoSync = true;
+    metaData_.storeType = DistributedRdb::RDB_DEVICE_COLLABORATION;
+    metaData_.storeId = "test_cloud_service_impl_store";
+    metaData_.dataDir = "/test_cloud_service_impl_store";
+}
 
 void CloudServiceImplTest::SetUpTestCase(void)
 {
-    metaDataManagerMock = std::make_shared<MetaDataManagerMock>();
-    BMetaDataManager::metaDataManager = metaDataManagerMock;
     size_t max = 12;
     size_t min = 5;
     auto executor = std::make_shared<ExecutorPool>(max, min);
     DeviceManagerAdapter::GetInstance().Init(executor);
+    Bootstrap::GetInstance().LoadCheckers();
+    CryptoManager::GetInstance().GenerateRootKey();
+    MetaDataManager::GetInstance().Initialize(dbStoreMock_, nullptr, "");
     NetworkDelegate::RegisterNetworkInstance(&delegate_);
+    InitMetaData();
 }
 
-void CloudServiceImplTest::TearDownTestCase()
-{
-    metaDataManagerMock = nullptr;
-    BMetaDataManager::metaDataManager = nullptr;
-}
+void CloudServiceImplTest::TearDownTestCase() { }
 
 void CloudServiceImplTest::SetUp() { }
 
@@ -549,10 +591,21 @@ HWTEST_F(CloudServiceImplTest, ConfirmInvitation001, TestSize.Level0)
  */
 HWTEST_F(CloudServiceImplTest, GetStoreMetaData_001, TestSize.Level1)
 {
-    EXPECT_CALL(*metaDataManagerMock, LoadMeta(_, _, _)).WillOnce(Return(true)).WillOnce(Return(false));
     StoreMetaData meta;
+    meta.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid;
+    meta.user = "0";
+    meta.bundleName = "bundleName";
+    meta.storeId = "storeName";
+    meta.dataDir = DirectoryManager::GetInstance().GetStorePath(meta) + "/" + meta.storeId;
+    EXPECT_EQ(MetaDataManager::GetInstance().SaveMeta(meta.GetKey(), meta, true), true);
     bool res = cloudServiceImpl_->GetStoreMetaData(meta);
-    EXPECT_EQ(res, false);
+    EXPECT_EQ(res, true);
+    EXPECT_EQ(MetaDataManager::GetInstance().DelMeta(meta.GetKey(), true), true);
+    meta.instanceId = 1;
+    EXPECT_EQ(MetaDataManager::GetInstance().SaveMeta(meta.GetKey(), meta, true), true);
+    res = cloudServiceImpl_->GetStoreMetaData(meta);
+    EXPECT_EQ(res, true);
+    EXPECT_EQ(MetaDataManager::GetInstance().DelMeta(meta.GetKey(), true), true);
 }
 
 /**
@@ -562,11 +615,54 @@ HWTEST_F(CloudServiceImplTest, GetStoreMetaData_001, TestSize.Level1)
  */
 HWTEST_F(CloudServiceImplTest, GetStoreMetaData_002, TestSize.Level1)
 {
-    EXPECT_CALL(*metaDataManagerMock, LoadMeta(_, _, _)).WillOnce(Return(false)).WillOnce(Return(false));
+    StoreMetaMapping metaMapping;
+    metaMapping.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid;
+    metaMapping.user = "0";
+    metaMapping.bundleName = "bundleName";
+    metaMapping.storeId = "storeName";
+    metaMapping.cloudPath = DirectoryManager::GetInstance().GetStorePath(metaMapping) + "/" + metaMapping.storeId;
+    EXPECT_EQ(MetaDataManager::GetInstance().SaveMeta(metaMapping.GetKey(), metaMapping, true), true);
+ 
     StoreMetaData meta;
-    meta.user = "0";
+    meta.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid;
+    meta.user = "100";
+    meta.bundleName = "bundleName";
+    meta.storeId = "storeName";
+    EXPECT_EQ(MetaDataManager::GetInstance().SaveMeta(meta.GetKey(), meta, true), true);
     bool res = cloudServiceImpl_->GetStoreMetaData(meta);
     EXPECT_EQ(res, false);
+ 
+    EXPECT_EQ(MetaDataManager::GetInstance().DelMeta(meta.GetKey(), true), true);
+    EXPECT_EQ(MetaDataManager::GetInstance().DelMeta(metaMapping.GetKey(), true), true);
+    meta.instanceId = 1;
+    metaMapping.instanceId = 1;
+    EXPECT_EQ(MetaDataManager::GetInstance().SaveMeta(meta.GetKey(), meta, true), true);
+    EXPECT_EQ(MetaDataManager::GetInstance().SaveMeta(metaMapping.GetKey(), metaMapping, true), true);
+    meta.user = "100";
+    res = cloudServiceImpl_->GetStoreMetaData(meta);
+    EXPECT_EQ(res, false);
+ 
+    EXPECT_EQ(MetaDataManager::GetInstance().DelMeta(meta.GetKey(), true), true);
+    EXPECT_EQ(MetaDataManager::GetInstance().DelMeta(metaMapping.GetKey(), true), true);
+    metaMapping.cloudPath = "";
+    metaMapping.dataDir = DirectoryManager::GetInstance().GetStorePath(metaMapping) + "/" + metaMapping.storeId;
+    EXPECT_EQ(MetaDataManager::GetInstance().SaveMeta(meta.GetKey(), meta, true), true);
+    EXPECT_EQ(MetaDataManager::GetInstance().SaveMeta(metaMapping.GetKey(), metaMapping, true), true);
+    meta.user = "100";
+    res = cloudServiceImpl_->GetStoreMetaData(meta);
+    EXPECT_EQ(res, false);
+ 
+    EXPECT_EQ(MetaDataManager::GetInstance().DelMeta(meta.GetKey(), true), true);
+    EXPECT_EQ(MetaDataManager::GetInstance().DelMeta(metaMapping.GetKey(), true), true);
+    metaMapping.dataDir = "";
+    EXPECT_EQ(MetaDataManager::GetInstance().SaveMeta(metaMapping.GetKey(), metaMapping, true), true);
+    EXPECT_EQ(MetaDataManager::GetInstance().SaveMeta(meta.GetKey(), meta, true), true);
+    meta.user = "100";
+    res = cloudServiceImpl_->GetStoreMetaData(meta);
+    EXPECT_EQ(res, false);
+ 
+    EXPECT_EQ(MetaDataManager::GetInstance().DelMeta(metaMapping.GetKey(), true), true);
+    EXPECT_EQ(MetaDataManager::GetInstance().DelMeta(meta.GetKey(), true), true);
 }
 
 /**
@@ -576,11 +672,30 @@ HWTEST_F(CloudServiceImplTest, GetStoreMetaData_002, TestSize.Level1)
  */
 HWTEST_F(CloudServiceImplTest, GetStoreMetaData_003, TestSize.Level1)
 {
-    EXPECT_CALL(*metaDataManagerMock, LoadMeta(_, _, _)).WillOnce(Return(false)).WillOnce(Return(false));
+    StoreMetaMapping metaMapping;
+    metaMapping.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid;
+    metaMapping.user = "0";
+    metaMapping.bundleName = "bundleName";
+    metaMapping.storeId = "storeName";
+    metaMapping.cloudPath = DirectoryManager::GetInstance().GetStorePath(metaMapping) + "/" + metaMapping.storeId;
+    EXPECT_EQ(MetaDataManager::GetInstance().SaveMeta(metaMapping.GetKey(), metaMapping, true), true);
     StoreMetaData meta;
+    meta.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid;
     meta.user = "100";
+    meta.bundleName = "bundleName";
+    meta.storeId = "storeName";
+    StoreMetaData meta1;
+    meta1.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid;
+    meta1.user = "0";
+    meta1.bundleName = "bundleName";
+    meta1.storeId = "storeName";
+    meta1.dataDir = DirectoryManager::GetInstance().GetStorePath(meta) + "/" + meta.storeId;
+    EXPECT_EQ(MetaDataManager::GetInstance().SaveMeta(meta1.GetKey(), meta1, true), true);
+    StoreMetaDataLocal localMetaData;
     bool res = cloudServiceImpl_->GetStoreMetaData(meta);
     EXPECT_EQ(res, false);
+    EXPECT_EQ(MetaDataManager::GetInstance().DelMeta(metaMapping.GetKey(), true), true);
+    EXPECT_EQ(MetaDataManager::GetInstance().DelMeta(meta1.GetKey(), true), true);
 }
 
 /**
@@ -591,11 +706,53 @@ HWTEST_F(CloudServiceImplTest, GetStoreMetaData_003, TestSize.Level1)
  */
 HWTEST_F(CloudServiceImplTest, GetStoreMetaData_004, TestSize.Level1)
 {
-    EXPECT_CALL(*metaDataManagerMock, LoadMeta(_, _, _)).WillOnce(Return(false)).WillRepeatedly(Return(true));
+    StoreMetaMapping metaMapping;
+    metaMapping.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid;
+    metaMapping.user = "0";
+    metaMapping.bundleName = "bundleName";
+    metaMapping.storeId = "storeName";
+    metaMapping.instanceId = 1;
+    metaMapping.cloudPath = DirectoryManager::GetInstance().GetStorePath(metaMapping) + "/" + metaMapping.storeId;
+    EXPECT_EQ(MetaDataManager::GetInstance().SaveMeta(metaMapping.GetKey(), metaMapping, true), true);
     StoreMetaData meta;
+    meta.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid;
     meta.user = "100";
+    meta.bundleName = "bundleName";
+    meta.storeId = "storeName";
+    meta.instanceId = 1;
+    StoreMetaData meta1;
+    meta1.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid;
+    meta1.user = "0";
+    meta1.bundleName = "bundleName";
+    meta1.storeId = "storeName";
+    meta1.instanceId = 1;
+    meta1.dataDir = DirectoryManager::GetInstance().GetStorePath(meta1) + "/" + meta1.storeId;
+    EXPECT_EQ(MetaDataManager::GetInstance().SaveMeta(meta1.GetKey(), meta1, true), true);
+    StoreMetaDataLocal localMetaData;
     bool res = cloudServiceImpl_->GetStoreMetaData(meta);
     EXPECT_EQ(res, false);
+    CheckDelMeta(metaMapping, meta, meta1);
+ 
+    EXPECT_EQ(MetaDataManager::GetInstance().DelMeta(meta1.GetKey(), true), true);
+    EXPECT_EQ(MetaDataManager::GetInstance().SaveMeta(meta1.GetKey(), meta1, true), true);
+    EXPECT_EQ(MetaDataManager::GetInstance().SaveMeta(meta1.GetKeyLocal(), localMetaData, true), true);
+    meta.user = "100";
+    res = cloudServiceImpl_->GetStoreMetaData(meta);
+    EXPECT_EQ(res, false);
+ 
+    EXPECT_EQ(MetaDataManager::GetInstance().DelMeta(meta1.GetKey(), true), true);
+    EXPECT_EQ(MetaDataManager::GetInstance().DelMeta(meta1.GetKeyLocal(), true), true);
+    localMetaData.isPublic = true;
+    EXPECT_EQ(MetaDataManager::GetInstance().SaveMeta(meta1.GetKey(), meta1, true), true);
+    EXPECT_EQ(MetaDataManager::GetInstance().SaveMeta(meta1.GetKeyLocal(), localMetaData, true), true);
+    meta.user = "100";
+    metaMapping.cloudPath = DirectoryManager::GetInstance().GetStorePath(meta1) + "/" + meta1.storeId;
+    EXPECT_EQ(MetaDataManager::GetInstance().SaveMeta(metaMapping.GetKey(), metaMapping, true), true);
+    res = cloudServiceImpl_->GetStoreMetaData(meta);
+    EXPECT_EQ(res, true);
+    EXPECT_EQ(MetaDataManager::GetInstance().DelMeta(metaMapping.GetKey(), true), true);
+    EXPECT_EQ(MetaDataManager::GetInstance().DelMeta(meta1.GetKey(), true), true);
+    EXPECT_EQ(MetaDataManager::GetInstance().DelMeta(meta1.GetKeyLocal(), true), true);
 }
 
 /**
@@ -605,17 +762,43 @@ HWTEST_F(CloudServiceImplTest, GetStoreMetaData_004, TestSize.Level1)
  */
 HWTEST_F(CloudServiceImplTest, PreShare_001, TestSize.Level1)
 {
-    EXPECT_CALL(*metaDataManagerMock, LoadMeta(_, _, _)).WillRepeatedly(Return(false));
     StoreInfo storeInfo;
-    storeInfo.path = "";
+    storeInfo.bundleName = "bundleName";
+    storeInfo.storeName = "storeName";
+    storeInfo.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid;
+    storeInfo.user = 100;
+    StoreMetaMapping storeMetaMapping;
+    storeMetaMapping.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid;
+    storeMetaMapping.user = "100";
+    storeMetaMapping.bundleName = "bundleName";
+    storeMetaMapping.storeId = "storeName";
+    EXPECT_EQ(MetaDataManager::GetInstance().SaveMeta(storeMetaMapping.GetKey(), storeMetaMapping, true), true);
     std::shared_ptr<GenQuery> query;
     auto [errCode, cursor] = cloudServiceImpl_->PreShare(storeInfo, *query);
     EXPECT_EQ(errCode, E_ERROR);
     ASSERT_EQ(cursor, nullptr);
-    storeInfo.path = "test";
-    std::tie(errCode, cursor) = cloudServiceImpl_->PreShare(storeInfo, *query);
-    EXPECT_EQ(errCode, E_ERROR);
-    ASSERT_EQ(cursor, nullptr);
+    storeInfo.path = "path";
+    storeMetaMapping.cloudPath = "path1";
+    EXPECT_EQ(MetaDataManager::GetInstance().DelMeta(storeMetaMapping.GetKey(), true), true);
+    EXPECT_EQ(MetaDataManager::GetInstance().SaveMeta(storeMetaMapping.GetKey(), storeMetaMapping, true), true);
+    auto [errCode1, cursor1] = cloudServiceImpl_->PreShare(storeInfo, *query);
+    EXPECT_EQ(errCode1, E_ERROR);
+    ASSERT_EQ(cursor1, nullptr);
+    storeInfo.path = "path";
+    storeMetaMapping.cloudPath = "path";
+    EXPECT_EQ(MetaDataManager::GetInstance().DelMeta(storeMetaMapping.GetKey(), true), true);
+    EXPECT_EQ(MetaDataManager::GetInstance().SaveMeta(storeMetaMapping.GetKey(), storeMetaMapping, true), true);
+    auto [errCode2, cursor2] = cloudServiceImpl_->PreShare(storeInfo, *query);
+    EXPECT_EQ(errCode2, E_ERROR);
+    ASSERT_EQ(cursor2, nullptr);
+    storeInfo.instanceId = 1;
+    storeMetaMapping.instanceId = 1;
+    EXPECT_EQ(MetaDataManager::GetInstance().DelMeta(storeMetaMapping.GetKey(), true), true);
+    EXPECT_EQ(MetaDataManager::GetInstance().SaveMeta(storeMetaMapping.GetKey(), storeMetaMapping, true), true);
+    auto [errCode3, cursor3] = cloudServiceImpl_->PreShare(storeInfo, *query);
+    EXPECT_EQ(errCode3, E_ERROR);
+    ASSERT_EQ(cursor3, nullptr);
+    EXPECT_EQ(MetaDataManager::GetInstance().DelMeta(storeMetaMapping.GetKey(), true), true);
 }
 
 /**
diff --git a/services/distributeddataservice/service/test/rdb_service_impl_test.cpp b/services/distributeddataservice/service/test/rdb_service_impl_test.cpp
index 628e584587324364c1275279a5ceb00c43258e7f..abe2488366efda20b6e61484c63261d102a69a26 100644
--- a/services/distributeddataservice/service/test/rdb_service_impl_test.cpp
+++ b/services/distributeddataservice/service/test/rdb_service_impl_test.cpp
@@ -123,6 +123,7 @@ void RdbServiceImplTest::SetUpTestCase()
     InitMetaData();
     Bootstrap::GetInstance().LoadCheckers();
     CryptoManager::GetInstance().GenerateRootKey();
+    MetaDataManager::GetInstance().Initialize(dbStoreMock_, nullptr, "");
 }
 
 void RdbServiceImplTest::TearDownTestCase()
@@ -339,6 +340,26 @@ HWTEST_F(RdbServiceImplTest, RemoteQuery002, TestSize.Level0)
     EXPECT_EQ(MetaDataManager::GetInstance().DelMeta(metaData_.GetKeyWithoutPath(), false), true);
 }
 
+/**
+ * @tc.name: RemoteQuery003
+ * @tc.desc: test RemoteQuery, when CheckAccess pass but query failed.
+ * @tc.type: FUNC
+ * @tc.require:
+ * @tc.author: zhaojh
+ */
+HWTEST_F(RdbServiceImplTest, RemoteQuery003, TestSize.Level0)
+{
+    RdbServiceImpl service;
+    RdbSyncerParam param;
+    param.bundleName_ = TEST_BUNDLE;
+    param.storeName_ = "RemoteQuery003";
+    std::vector<std::string> selectionArgs;
+    auto deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid;
+    auto ret = service.RemoteQuery(param, deviceId, "", selectionArgs);
+    EXPECT_EQ(ret.first, RDB_ERROR);
+    EXPECT_EQ(MetaDataManager::GetInstance().DelMeta(metaData_.GetKeyWithoutPath(), false), true);
+}
+
 /**
 * @tc.name: TransferStringToHex001
 * @tc.desc: test TransferStringToHex, param empty.
@@ -625,6 +646,31 @@ HWTEST_F(RdbServiceImplTest, DoAutoSync001, TestSize.Level0)
     EXPECT_EQ(result, RDB_ERROR);
 }
 
+/**
+ * @tc.name: DoAutoSync002
+ * @tc.desc: Test DoAutoSync when the store is null.
+ * @tc.type: FUNC
+ * @tc.require:
+ * @tc.author: my
+ */
+HWTEST_F(RdbServiceImplTest, DoAutoSync002, TestSize.Level0)
+{
+    StoreMetaMapping metaMapping;
+    InitMapping(metaMapping);
+    metaMapping.dataDir = "path";
+    metaMapping.devicePath = "path1";
+    EXPECT_EQ(MetaDataManager::GetInstance().SaveMeta(metaMapping.GetKey(), metaMapping, true), true);
+    RdbServiceImpl service;
+    std::vector<std::string> devices = {"device1"};
+    DistributedData::Database dataBase;
+    std::vector<std::string> tables = {"table1"};
+    dataBase.bundleName = "bundleName";
+    dataBase.name = "storeName";
+    dataBase.user = "100";
+    auto result = service.DoAutoSync(devices, dataBase, tables);
+    EXPECT_EQ(result, RDB_ERROR);
+}
+
 /**
  * @tc.name: DoOnlineSync001
  * @tc.desc: Test DoOnlineSync when all tables have deviceSyncFields.
@@ -756,6 +802,27 @@ HWTEST_F(RdbServiceImplTest, AfterOpen003, TestSize.Level0)
     EXPECT_EQ(MetaDataManager::GetInstance().DelMeta(metaData_.GetKeyWithoutPath(), false), true);
 }
 
+/**
+ * @tc.name: AfterOpen004
+ * @tc.desc: Test AfterOpen when CheckAccess pass and CheckParam pass.
+ * @tc.type: FUNC
+ * @tc.require:
+ * @tc.author: zd
+ */
+HWTEST_F(RdbServiceImplTest, AfterOpen004, TestSize.Level0)
+{
+    metaData_.isSearchable = true;
+    EXPECT_EQ(MetaDataManager::GetInstance().SaveMeta(metaData_.GetKeyWithoutPath(), metaData_, false), true);
+    RdbServiceImpl service;
+    RdbSyncerParam param;
+    param.bundleName_ = metaData_.bundleName;
+    param.storeName_ = metaData_.storeId;
+    int32_t result = service.AfterOpen(param);
+ 
+    EXPECT_EQ(result, RDB_OK);
+    EXPECT_EQ(MetaDataManager::GetInstance().DelMeta(metaData_.GetKeyWithoutPath(), false), true);
+}
+
 /**
  * @tc.name: NotifyDataChange001
  * @tc.desc: Test NotifyDataChange when CheckParam not pass.
@@ -1112,6 +1179,39 @@ HWTEST_F(RdbServiceImplTest, SetDistributedTables003, TestSize.Level0)
     EXPECT_EQ(result, RDB_ERROR);
 }
 
+/**
+ * @tc.name: SetDistributedTables004
+ * @tc.desc: Test SetDistributedTables when type is device.
+ * @tc.type: FUNC
+ * @tc.require:
+ * @tc.author: zhaojh
+ */
+HWTEST_F(RdbServiceImplTest, SetDistributedTables004, TestSize.Level0)
+{
+    RdbServiceImpl service;
+    RdbSyncerParam param;
+    param.bundleName_ = TEST_BUNDLE;
+    param.storeName_ = "SetDistributedTables004";
+    param.type_ = StoreMetaData::StoreType::STORE_RELATIONAL_BEGIN;
+    std::vector<std::string> tables;
+    std::vector<OHOS::DistributedRdb::Reference> references;
+
+    auto meta = service.GetStoreMetaData(param);
+    ASSERT_EQ(MetaDataManager::GetInstance().SaveMeta(meta.GetKey(), meta, true), true);
+
+    auto creator = [](const StoreMetaData &metaData) -> GeneralStore* {
+        auto store = new (std::nothrow) GeneralStoreMock();
+        return store;
+    };
+    AutoCache::GetInstance().RegCreator(DistributedRdb::RDB_DEVICE_COLLABORATION, creator);
+
+    int32_t result =
+        service.SetDistributedTables(param, tables, references, false,
+                                     DistributedTableType::DISTRIBUTED_DEVICE);
+    EXPECT_EQ(result, RDB_OK);
+    ASSERT_EQ(MetaDataManager::GetInstance().DelMeta(meta.GetKey(), true), true);
+}
+
 /**
  * @tc.name: Sync001
  * @tc.desc: Test Sync when CheckAccess not pass.
@@ -1151,6 +1251,47 @@ HWTEST_F(RdbServiceImplTest, Sync002, TestSize.Level0)
     EXPECT_EQ(result, RDB_ERROR);
 }
 
+/**
+ * @tc.name: Sync003
+ * @tc.desc: Test Sync when mode is nearby begin.
+ * @tc.type: FUNC
+ * @tc.require:
+ * @tc.author: zhaojh
+ */
+HWTEST_F(RdbServiceImplTest, Sync003, TestSize.Level0)
+{
+    RdbServiceImpl service;
+    RdbSyncerParam param;
+    param.bundleName_ = TEST_BUNDLE;
+    param.storeName_ = "Sync003";
+    RdbService::Option option { DistributedData::GeneralStore::NEARBY_BEGIN };
+    PredicatesMemo predicates;
+
+    int32_t result = service.Sync(param, option, predicates, nullptr);
+    EXPECT_EQ(result, RDB_OK);
+}
+
+/**
+ * @tc.name: Sync004
+ * @tc.desc: Test Sync when mode is cloud begin.
+ * @tc.type: FUNC
+ * @tc.require:
+ * @tc.author: zhaojh
+ */
+HWTEST_F(RdbServiceImplTest, Sync004, TestSize.Level0)
+{
+    RdbServiceImpl service;
+    RdbSyncerParam param;
+    param.bundleName_ = TEST_BUNDLE;
+    param.storeName_ = "Sync004";
+    RdbService::Option option { DistributedData::GeneralStore::CLOUD_BEGIN };
+    PredicatesMemo predicates;
+
+    int32_t result = service.Sync(param, option, predicates, nullptr);
+    EXPECT_EQ(result, RDB_OK);
+}
+
+
 /**
  * @tc.name: QuerySharingResource001
  * @tc.desc: Test QuerySharingResource when CheckParam not pass.
@@ -1529,6 +1670,45 @@ HWTEST_F(RdbServiceImplTest, VerifyPromiseInfo002, TestSize.Level0)
     EXPECT_EQ(MetaDataManager::GetInstance().DelMeta(metaData_.GetKeyLocal(), true), true);
 }
 
+/**
+ * @tc.name: VerifyPromiseInfo003
+ * @tc.desc: Test VerifyPromiseInfo when tokenId and uid are not in promiseInfo.
+ * @tc.type: FUNC
+ * @tc.require:
+ * @tc.author: zhaojh
+ */
+HWTEST_F(RdbServiceImplTest, VerifyPromiseInfo003, TestSize.Level0)
+{
+    StoreMetaDataLocal localMeta;
+    auto tokenId = IPCSkeleton::GetCallingTokenID();
+    localMeta.isAutoSync = true;
+    localMeta.promiseInfo.tokenIds = {tokenId};
+    localMeta.promiseInfo.uids = {};
+    localMeta.promiseInfo.permissionNames = {};
+    metaData_.dataDir = "path";
+    EXPECT_EQ(MetaDataManager::GetInstance().SaveMeta(metaData_.GetKeyLocal(), localMeta, true), true);
+
+    StoreMetaMapping storeMetaMapping(metaData_);
+    storeMetaMapping.dataDir = DirectoryManager::GetInstance().GetStorePath(metaData_) + "/" + TEST_STORE;
+
+    RdbServiceImpl service;
+    RdbSyncerParam param;
+    param.bundleName_ = metaData_.bundleName;
+    param.type_ = metaData_.storeType;
+    param.level_ = metaData_.securityLevel;
+    param.area_ = metaData_.area;
+    param.hapName_ = metaData_.bundleName;
+    param.storeName_ = metaData_.storeId;
+    param.isEncrypt_ = metaData_.isEncrypt;
+    param.isSearchable_ = metaData_.isSearchable;
+    param.haMode_ = metaData_.haMode;
+    param.asyncDownloadAsset_ = metaData_.asyncDownloadAsset;
+    param.user_ = metaData_.user;
+    int32_t result = service.VerifyPromiseInfo(param);
+    EXPECT_EQ(result, RDB_ERROR);
+    EXPECT_EQ(MetaDataManager::GetInstance().DelMeta(metaData_.GetKeyLocal(), true), true);
+}
+
 /**
  * @tc.name: CheckParam001
  * @tc.desc: Test VerifyPromiseInfo when bundleName_ contain '/'.
@@ -1828,132 +2008,188 @@ HWTEST_F(RdbServiceImplTest, Delete_001, TestSize.Level1)
     param.bundleName_ = "";
     auto errCode = service.Delete(param);
     EXPECT_EQ(errCode, RDB_ERROR);
+    param.bundleName_ = "bundleName";
+    param.storeName_ = "storeName";
+    param.user_ =  "0";
+    errCode = service.Delete(param);
+    EXPECT_EQ(errCode, RDB_OK);
 }
 
 /**
- * @tc.name: RegisterEvent_001
- * @tc.desc: Test Delete when param is invalid.
+ * @tc.name: Delete_002
+ * @tc.desc: Test Delete_002.
  * @tc.type: FUNC
  */
-HWTEST_F(RdbServiceImplTest, RegisterEvent_001, TestSize.Level1)
+HWTEST_F(RdbServiceImplTest, Delete_002, TestSize.Level1)
 {
+    StoreMetaMapping metaMapping;
+    metaMapping.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid;
+    metaMapping.user = "0";
+    metaMapping.bundleName = "bundleName";
+    metaMapping.storeId = "storeName";
+    metaMapping.instanceId = 1;
+
+    StoreMetaData meta1;
+    meta1.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid;
+    meta1.user = "0";
+    meta1.bundleName = "bundleName";
+    meta1.storeId = "storeName";
+    meta1.dataDir = DirectoryManager::GetInstance().GetStorePath(meta1) + "/" + metaMapping.storeId;
+    meta1.instanceId = 1;
+    EXPECT_EQ(MetaDataManager::GetInstance().SaveMeta(meta1.GetKey(), meta1, true), true);
+
+    metaMapping.cloudPath = meta1.dataDir;
+    metaMapping.devicePath = meta1.dataDir;
+    metaMapping.searchPath = meta1.dataDir;
+    metaMapping.dataDir = meta1.dataDir;
+    EXPECT_EQ(MetaDataManager::GetInstance().SaveMeta(metaMapping.GetKey(), metaMapping, true), true);
+
+    StoreMetaData meta2;
+    meta2.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid;
+    meta2.user = "0";
+    meta2.bundleName = "bundleName";
+    meta2.storeId = "storeName";
+    meta2.dataDir ="path2";
+    meta2.instanceId = 1;
+    EXPECT_EQ(MetaDataManager::GetInstance().SaveMeta(meta2.GetKey(), meta2, true), true);
+
     RdbServiceImpl service;
-    DistributedData::StoreInfo storeInfo;
-    storeInfo.bundleName = "RegisterEvent_bundleName";
-    storeInfo.storeName = "RegisterEvent_storeName";
-    storeInfo.user = 100;
-    storeInfo.path = "RegisterEvent_path";
-    auto event = std::make_unique<CloudEvent>(CloudEvent::CLOUD_SYNC, storeInfo);
-    EXPECT_NE(event, nullptr);
-    auto result = EventCenter::GetInstance().PostEvent(move(event));
-    EXPECT_EQ(result, 1); // CODE_SYNC
+    RdbSyncerParam param;
+    param.bundleName_ = metaMapping.bundleName;
+    param.storeName_ = metaMapping.storeId;
+    param.user_ = metaMapping.user;
+    auto errCode = service.Delete(param);
+    EXPECT_EQ(errCode, RDB_OK);
+    MetaDataManager::GetInstance().LoadMeta(metaMapping.GetKey(), metaMapping, true);
+    EXPECT_EQ(metaMapping.cloudPath, "");
+    EXPECT_EQ(metaMapping.devicePath, "");
+    EXPECT_EQ(metaMapping.searchPath, "");
+    EXPECT_EQ(MetaDataManager::GetInstance().DelMeta(metaMapping.GetKey(), true), true);
+    EXPECT_EQ(MetaDataManager::GetInstance().DelMeta(meta1.GetKey(), true), true);
+    EXPECT_EQ(MetaDataManager::GetInstance().DelMeta(meta2.GetKey(), true), true);
 }
 
 /**
- * @tc.name: RegisterEvent_002
- * @tc.desc: Test Delete when param is invalid.
+ * @tc.name: Delete_003
+ * @tc.desc: Test Delete_003.
  * @tc.type: FUNC
  */
-HWTEST_F(RdbServiceImplTest, RegisterEvent_002, TestSize.Level1)
+HWTEST_F(RdbServiceImplTest, Delete_003, TestSize.Level1)
 {
     StoreMetaMapping metaMapping;
-    InitMapping(metaMapping);
+    metaMapping.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid;
+    metaMapping.user = "0";
+    metaMapping.bundleName = "bundleName";
+    metaMapping.storeId = "storeName";
+
+    StoreMetaData meta1;
+    meta1.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid;
+    meta1.user = "0";
+    meta1.bundleName = "bundleName";
+    meta1.storeId = "storeName";
+    meta1.dataDir = DirectoryManager::GetInstance().GetStorePath(meta1) + "/" + metaMapping.storeId;
+    EXPECT_EQ(MetaDataManager::GetInstance().SaveMeta(meta1.GetKey(), meta1, true), true);
+
+    metaMapping.cloudPath = "path2";
+    metaMapping.devicePath = "path2";
+    metaMapping.searchPath = "path2";
+    metaMapping.dataDir = meta1.dataDir;
     EXPECT_EQ(MetaDataManager::GetInstance().SaveMeta(metaMapping.GetKey(), metaMapping, true), true);
 
-    RdbServiceImpl service;
-    DistributedData::StoreInfo storeInfo;
-    storeInfo.bundleName = "bundleName";
-    storeInfo.storeName = "storeName";
-    storeInfo.user = 100;
-    storeInfo.path = "path";
-    auto event = std::make_unique<CloudEvent>(CloudEvent::CLOUD_SYNC, storeInfo);
-    EXPECT_NE(event, nullptr);
-    auto result = EventCenter::GetInstance().PostEvent(move(event));
-    EXPECT_EQ(result, 1); // CODE_SYNC
+    StoreMetaData meta2;
+    meta2.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid;
+    meta2.user = "0";
+    meta2.bundleName = "bundleName";
+    meta2.storeId = "storeName";
+    meta2.dataDir ="path2";
+    EXPECT_EQ(MetaDataManager::GetInstance().SaveMeta(meta2.GetKey(), meta2, true), true);
 
+    RdbServiceImpl service;
+    RdbSyncerParam param;
+    param.bundleName_ = metaMapping.bundleName;
+    param.storeName_ = metaMapping.storeId;
+    param.user_ = metaMapping.user;
+    auto errCode = service.Delete(param);
+    EXPECT_EQ(errCode, RDB_OK);
+    MetaDataManager::GetInstance().LoadMeta(metaMapping.GetKey(), metaMapping, true);
+    EXPECT_EQ(metaMapping.cloudPath, "path2");
+    EXPECT_EQ(metaMapping.devicePath, "path2");
+    EXPECT_EQ(metaMapping.searchPath, "path2");
     EXPECT_EQ(MetaDataManager::GetInstance().DelMeta(metaMapping.GetKey(), true), true);
+    EXPECT_EQ(MetaDataManager::GetInstance().DelMeta(meta1.GetKey(), true), true);
+    EXPECT_EQ(MetaDataManager::GetInstance().DelMeta(meta2.GetKey(), true), true);
 }
 
-
 /**
- * @tc.name: RegisterEvent_003
- * @tc.desc: Test Delete when param is invalid.
+ * @tc.name: Delete_004
+ * @tc.desc: Test Delete_004.
  * @tc.type: FUNC
  */
-HWTEST_F(RdbServiceImplTest, RegisterEvent_003, TestSize.Level1)
+HWTEST_F(RdbServiceImplTest, Delete_004, TestSize.Level1)
 {
     StoreMetaMapping metaMapping;
-    InitMapping(metaMapping);
-    metaMapping.cloudPath ="path";
-    metaMapping.dataDir ="path";
+    metaMapping.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid;
+    metaMapping.user = "0";
+    metaMapping.bundleName = "bundleName";
+    metaMapping.storeId = "storeName";
+    metaMapping.instanceId = 1;
+
+    StoreMetaData meta1;
+    meta1.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid;
+    meta1.user = "0";
+    meta1.bundleName = "bundleName";
+    meta1.storeId = "storeName";
+    meta1.dataDir = "path1";
+    meta1.instanceId = 1;
+    EXPECT_EQ(MetaDataManager::GetInstance().SaveMeta(meta1.GetKey(), meta1, true), true);
+
+    metaMapping.cloudPath = "path2";
+    metaMapping.devicePath = "path2";
+    metaMapping.searchPath = "path2";
+    metaMapping.dataDir = DirectoryManager::GetInstance().GetStorePath(meta1) + "/" + metaMapping.storeId;
     EXPECT_EQ(MetaDataManager::GetInstance().SaveMeta(metaMapping.GetKey(), metaMapping, true), true);
 
-    StoreMetaData meta(metaMapping);
-    meta.dataDir ="path1";
-    EXPECT_EQ(MetaDataManager::GetInstance().SaveMeta(meta.GetKey(), metaMapping, true), true);
     RdbServiceImpl service;
-    DistributedData::StoreInfo storeInfo;
-    storeInfo.bundleName = "bundleName";
-    storeInfo.storeName = "storeName";
-    storeInfo.user = 100;
-    storeInfo.path = "path";
-    auto event = std::make_unique<CloudEvent>(CloudEvent::CLOUD_SYNC, storeInfo);
-    EXPECT_NE(event, nullptr);
-    auto result = EventCenter::GetInstance().PostEvent(move(event));
-    EXPECT_EQ(result, 1); // CODE_SYNC
-
+    RdbSyncerParam param;
+    param.bundleName_ = metaMapping.bundleName;
+    param.storeName_ = metaMapping.storeId;
+    param.user_ = metaMapping.user;
+    auto errCode = service.Delete(param);
+    EXPECT_EQ(errCode, RDB_OK);
     EXPECT_EQ(MetaDataManager::GetInstance().DelMeta(metaMapping.GetKey(), true), true);
-    EXPECT_EQ(MetaDataManager::GetInstance().DelMeta(meta.GetKey(), true), true);
+    EXPECT_EQ(MetaDataManager::GetInstance().DelMeta(meta1.GetKey(), true), true);
 }
 
 /**
- * @tc.name: RegisterEvent_004
- * @tc.desc: Test Delete when param is invalid.
+ * @tc.name: RegisterEvent_001
+ * @tc.desc: Test RegisterEvent_001.
  * @tc.type: FUNC
  */
-HWTEST_F(RdbServiceImplTest, RegisterEvent_004, TestSize.Level1)
+HWTEST_F(RdbServiceImplTest, RegisterEvent_001, TestSize.Level1)
 {
-    StoreMetaMapping metaMapping;
-    InitMapping(metaMapping);
-    metaMapping.cloudPath ="path";
-    metaMapping.dataDir ="path";
-    EXPECT_EQ(MetaDataManager::GetInstance().SaveMeta(metaMapping.GetKey(), metaMapping, true), true);
-
-    StoreMetaData meta(metaMapping);
-    meta.storeType = StoreMetaData::STORE_KV_BEGIN;
-    EXPECT_EQ(MetaDataManager::GetInstance().SaveMeta(meta.GetKey(), metaMapping, true), true);
     RdbServiceImpl service;
     DistributedData::StoreInfo storeInfo;
-    storeInfo.bundleName = "bundleName";
-    storeInfo.storeName = "storeName";
+    storeInfo.bundleName = "RegisterEvent_bundleName";
+    storeInfo.storeName = "RegisterEvent_storeName";
     storeInfo.user = 100;
-    storeInfo.path = "path";
+    storeInfo.path = "RegisterEvent_path";
     auto event = std::make_unique<CloudEvent>(CloudEvent::CLOUD_SYNC, storeInfo);
     EXPECT_NE(event, nullptr);
     auto result = EventCenter::GetInstance().PostEvent(move(event));
     EXPECT_EQ(result, 1); // CODE_SYNC
-
-    EXPECT_EQ(MetaDataManager::GetInstance().DelMeta(metaMapping.GetKey(), true), true);
-    EXPECT_EQ(MetaDataManager::GetInstance().DelMeta(meta.GetKey(), true), true);
 }
 
 /**
- * @tc.name: RegisterEvent_005
- * @tc.desc: Test Delete when param is invalid.
+ * @tc.name: RegisterEvent_002
+ * @tc.desc: Test RegisterEvent_002.
  * @tc.type: FUNC
  */
-HWTEST_F(RdbServiceImplTest, RegisterEvent_005, TestSize.Level1)
+HWTEST_F(RdbServiceImplTest, RegisterEvent_002, TestSize.Level1)
 {
     StoreMetaMapping metaMapping;
     InitMapping(metaMapping);
-    metaMapping.cloudPath ="path";
-    metaMapping.dataDir ="path";
     EXPECT_EQ(MetaDataManager::GetInstance().SaveMeta(metaMapping.GetKey(), metaMapping, true), true);
 
-    StoreMetaData meta(metaMapping);
-
-    meta.storeType = StoreMetaData::STORE_OBJECT_BEGIN;
-    EXPECT_EQ(MetaDataManager::GetInstance().SaveMeta(meta.GetKey(), metaMapping, true), true);
     RdbServiceImpl service;
     DistributedData::StoreInfo storeInfo;
     storeInfo.bundleName = "bundleName";
@@ -1966,25 +2202,29 @@ HWTEST_F(RdbServiceImplTest, RegisterEvent_005, TestSize.Level1)
     EXPECT_EQ(result, 1); // CODE_SYNC
 
     EXPECT_EQ(MetaDataManager::GetInstance().DelMeta(metaMapping.GetKey(), true), true);
-    EXPECT_EQ(MetaDataManager::GetInstance().DelMeta(meta.GetKey(), true), true);
 }
 
+
 /**
- * @tc.name: RegisterEvent_006
- * @tc.desc: Test Delete when param is invalid.
+ * @tc.name: RegisterEvent_003
+ * @tc.desc: Test RegisterEvent_003.
  * @tc.type: FUNC
  */
-HWTEST_F(RdbServiceImplTest, RegisterEvent_006, TestSize.Level1)
+HWTEST_F(RdbServiceImplTest, RegisterEvent_003, TestSize.Level1)
 {
     StoreMetaMapping metaMapping;
     InitMapping(metaMapping);
-    metaMapping.cloudPath ="path";
+    metaMapping.cloudPath ="path1";
     metaMapping.dataDir ="path";
     EXPECT_EQ(MetaDataManager::GetInstance().SaveMeta(metaMapping.GetKey(), metaMapping, true), true);
 
-    StoreMetaData meta(metaMapping);
-    meta.storeType = StoreMetaData::STORE_RELATIONAL_BEGIN;
-    EXPECT_EQ(MetaDataManager::GetInstance().SaveMeta(meta.GetKey(), metaMapping, true), true);
+    StoreMetaData meta;
+    meta.deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid;
+    meta.user = "100";
+    meta.bundleName = "bundleName";
+    meta.storeId = "storeName";
+    meta.dataDir ="path1";
+    EXPECT_EQ(MetaDataManager::GetInstance().SaveMeta(meta.GetKey(), meta, true), true);
     RdbServiceImpl service;
     DistributedData::StoreInfo storeInfo;
     storeInfo.bundleName = "bundleName";
@@ -2001,21 +2241,19 @@ HWTEST_F(RdbServiceImplTest, RegisterEvent_006, TestSize.Level1)
 }
 
 /**
- * @tc.name: RegisterEvent_007
- * @tc.desc: Test Delete when param is invalid.
+ * @tc.name: RegisterEvent_004
+ * @tc.desc: Test RegisterEvent_005.
  * @tc.type: FUNC
  */
-HWTEST_F(RdbServiceImplTest, RegisterEvent_007, TestSize.Level1)
+HWTEST_F(RdbServiceImplTest, RegisterEvent_004, TestSize.Level1)
 {
     StoreMetaMapping metaMapping;
     InitMapping(metaMapping);
     metaMapping.cloudPath ="path";
     metaMapping.dataDir ="path";
+    metaMapping.storeType = StoreMetaData::STORE_KV_BEGIN;
     EXPECT_EQ(MetaDataManager::GetInstance().SaveMeta(metaMapping.GetKey(), metaMapping, true), true);
 
-    StoreMetaData meta(metaMapping);
-    meta.storeType = StoreMetaData::STORE_RELATIONAL_END;
-    EXPECT_EQ(MetaDataManager::GetInstance().SaveMeta(meta.GetKey(), metaMapping, true), true);
     RdbServiceImpl service;
     DistributedData::StoreInfo storeInfo;
     storeInfo.bundleName = "bundleName";
@@ -2028,26 +2266,22 @@ HWTEST_F(RdbServiceImplTest, RegisterEvent_007, TestSize.Level1)
     EXPECT_EQ(result, 1); // CODE_SYNC
 
     EXPECT_EQ(MetaDataManager::GetInstance().DelMeta(metaMapping.GetKey(), true), true);
-    EXPECT_EQ(MetaDataManager::GetInstance().DelMeta(meta.GetKey(), true), true);
 }
 
 /**
- * @tc.name: RegisterEvent_008
- * @tc.desc: Test Delete when param is invalid.
+ * @tc.name: RegisterEvent_005
+ * @tc.desc: Test RegisterEvent_005
  * @tc.type: FUNC
  */
-HWTEST_F(RdbServiceImplTest, RegisterEvent_008, TestSize.Level1)
+HWTEST_F(RdbServiceImplTest, RegisterEvent_005, TestSize.Level1)
 {
     StoreMetaMapping metaMapping;
     InitMapping(metaMapping);
     metaMapping.cloudPath ="path";
     metaMapping.dataDir ="path";
+    metaMapping.storeType = StoreMetaData::STORE_OBJECT_BEGIN;
     EXPECT_EQ(MetaDataManager::GetInstance().SaveMeta(metaMapping.GetKey(), metaMapping, true), true);
 
-    StoreMetaData meta(metaMapping);
-    meta.dataDir = "path1";
-    EXPECT_EQ(MetaDataManager::GetInstance().SaveMeta(meta.GetKey(), metaMapping, true), true);
-
     RdbServiceImpl service;
     DistributedData::StoreInfo storeInfo;
     storeInfo.bundleName = "bundleName";
@@ -2060,24 +2294,21 @@ HWTEST_F(RdbServiceImplTest, RegisterEvent_008, TestSize.Level1)
     EXPECT_EQ(result, 1); // CODE_SYNC
 
     EXPECT_EQ(MetaDataManager::GetInstance().DelMeta(metaMapping.GetKey(), true), true);
-    EXPECT_EQ(MetaDataManager::GetInstance().DelMeta(meta.GetKey(), true), true);
 }
 
 /**
- * @tc.name: RegisterEvent_009
- * @tc.desc: Test Delete when param is invalid.
+ * @tc.name: RegisterEvent_006
+ * @tc.desc: Test RegisterEvent_006
  * @tc.type: FUNC
  */
-HWTEST_F(RdbServiceImplTest, RegisterEvent_009, TestSize.Level1)
+HWTEST_F(RdbServiceImplTest, RegisterEvent_006, TestSize.Level1)
 {
     StoreMetaMapping metaMapping;
     InitMapping(metaMapping);
-    metaMapping.cloudPath ="path";
+    metaMapping.cloudPath ="path1";
     metaMapping.dataDir ="path";
     EXPECT_EQ(MetaDataManager::GetInstance().SaveMeta(metaMapping.GetKey(), metaMapping, true), true);
 
-    StoreMetaData meta(metaMapping);
-    EXPECT_EQ(MetaDataManager::GetInstance().SaveMeta(meta.GetKey(), metaMapping, true), true);
     RdbServiceImpl service;
     DistributedData::StoreInfo storeInfo;
     storeInfo.bundleName = "bundleName";
@@ -2090,100 +2321,6 @@ HWTEST_F(RdbServiceImplTest, RegisterEvent_009, TestSize.Level1)
     EXPECT_EQ(result, 1); // CODE_SYNC
 
     EXPECT_EQ(MetaDataManager::GetInstance().DelMeta(metaMapping.GetKey(), true), true);
-    EXPECT_EQ(MetaDataManager::GetInstance().DelMeta(meta.GetKey(), true), true);
-}
-
-/**
- * @tc.name: SetDistributedTables004
- * @tc.desc: Test SetDistributedTables when type is device.
- * @tc.type: FUNC
- * @tc.require:
- * @tc.author: zhaojh
- */
-HWTEST_F(RdbServiceImplTest, SetDistributedTables004, TestSize.Level0)
-{
-    RdbServiceImpl service;
-    RdbSyncerParam param;
-    param.bundleName_ = TEST_BUNDLE;
-    param.storeName_ = "SetDistributedTables004";
-    param.type_ = StoreMetaData::StoreType::STORE_RELATIONAL_BEGIN;
-    std::vector<std::string> tables;
-    std::vector<OHOS::DistributedRdb::Reference> references;
-
-    auto meta = service.GetStoreMetaData(param);
-    ASSERT_EQ(MetaDataManager::GetInstance().SaveMeta(meta.GetKey(), meta, true), true);
-
-    auto creator = [](const StoreMetaData &metaData) -> GeneralStore* {
-        auto store = new (std::nothrow) GeneralStoreMock();
-        return store;
-    };
-    AutoCache::GetInstance().RegCreator(DistributedRdb::RDB_DEVICE_COLLABORATION, creator);
-
-    int32_t result =
-        service.SetDistributedTables(param, tables, references, false,
-                                     DistributedTableType::DISTRIBUTED_DEVICE);
-    EXPECT_EQ(result, RDB_OK);
-    ASSERT_EQ(MetaDataManager::GetInstance().DelMeta(meta.GetKey(), true), true);
-}
-
-/**
- * @tc.name: RemoteQuery003
- * @tc.desc: test RemoteQuery, when CheckAccess pass but query failed.
- * @tc.type: FUNC
- * @tc.require:
- * @tc.author: zhaojh
- */
-HWTEST_F(RdbServiceImplTest, RemoteQuery003, TestSize.Level0)
-{
-    RdbServiceImpl service;
-    RdbSyncerParam param;
-    param.bundleName_ = TEST_BUNDLE;
-    param.storeName_ = "RemoteQuery003";
-    std::vector<std::string> selectionArgs;
-    auto deviceId = DmAdapter::GetInstance().GetLocalDevice().uuid;
-    auto ret = service.RemoteQuery(param, deviceId, "", selectionArgs);
-    EXPECT_EQ(ret.first, RDB_ERROR);
-    EXPECT_EQ(MetaDataManager::GetInstance().DelMeta(metaData_.GetKeyWithoutPath(), false), true);
-}
-
-/**
- * @tc.name: Sync003
- * @tc.desc: Test Sync when mode is nearby begin.
- * @tc.type: FUNC
- * @tc.require:
- * @tc.author: zhaojh
- */
-HWTEST_F(RdbServiceImplTest, Sync003, TestSize.Level0)
-{
-    RdbServiceImpl service;
-    RdbSyncerParam param;
-    param.bundleName_ = TEST_BUNDLE;
-    param.storeName_ = "Sync003";
-    RdbService::Option option { DistributedData::GeneralStore::NEARBY_BEGIN };
-    PredicatesMemo predicates;
-
-    int32_t result = service.Sync(param, option, predicates, nullptr);
-    EXPECT_EQ(result, RDB_OK);
-}
-
-/**
- * @tc.name: Sync004
- * @tc.desc: Test Sync when mode is cloud begin.
- * @tc.type: FUNC
- * @tc.require:
- * @tc.author: zhaojh
- */
-HWTEST_F(RdbServiceImplTest, Sync004, TestSize.Level0)
-{
-    RdbServiceImpl service;
-    RdbSyncerParam param;
-    param.bundleName_ = TEST_BUNDLE;
-    param.storeName_ = "Sync004";
-    RdbService::Option option { DistributedData::GeneralStore::CLOUD_BEGIN };
-    PredicatesMemo predicates;
-
-    int32_t result = service.Sync(param, option, predicates, nullptr);
-    EXPECT_EQ(result, RDB_OK);
 }
 
 /**